Cream of the Crop 26/Cream of the Crop 26.iso/os2/gnumans.zip/as.inf

OS/2 Help File | 1997-07-02 | 192KB | 4,861 lines

ΓòÉΓòÉΓòÉ 1. Title page ΓòÉΓòÉΓòÉ

                                    Using as

                                The GNU Assembler

                                  January 1994

The Free Software Foundation Inc.  thanks The Nice Computer Company of
Australia for loaning Dean Elsner to write the first (Vax) version of as for
Project GNU. The proprietors, management and staff of TNCCA thank FSF for
distracting the boss while they got some work done.

                       Dean Elsner, Jay Fenlason & friends

Copyright (C) 1991, 1992, 1993, 1994 Free Software Foundation, Inc.

Permission is granted to make and distribute verbatim copies of this manual
provided the copyright notice and this permission notice are preserved on all
copies.

Permission is granted to copy and distribute modified versions of this manual
under the conditions for verbatim copying, provided that the entire resulting
derived work is distributed under the terms of a permission notice identical to
this one.

Permission is granted to copy and distribute translations of this manual into
another language, under the above conditions for modified versions.


ΓòÉΓòÉΓòÉ 2. Top node: "Using as" ΓòÉΓòÉΓòÉ

This file is a user guide to the gnu assembler as.

 Overview                                Overview
 Invoking                                Command-Line Options
 Syntax                                  Syntax
 Sections                                Sections and Relocation
 Symbols                                 Symbols
 Expressions                             Expressions
 Pseudo Ops                              Assembler Directives
 Machine Dependencies                    Machine Dependent Features
 Acknowledgements                        Who Did What
 Index                                   Index


ΓòÉΓòÉΓòÉ 3. Overview ΓòÉΓòÉΓòÉ

Here is a brief summary of how to invoke as.  For details, see Comand-Line
Options.

as [ -a[dhlns] ] [ -D ] [ -f ] [ -I path ]
 [ -K ] [ -L ] [ -o objfile ] [ -R ]
 [ --statistics] [ -v ] [ -W ] [ -Z ]
 [ -Av6 | -Av7 | -Av8 | -Asparclite | -bump ]
 [ -ACA | -ACA_A | -ACB | -ACC | -AKA | -AKB | -AKC | -AMC ]
 [ -b ] [ -norelax ]
 [ -l ] [ -m68000 | -m68010 | -m68020 | ... ]
 [ -nocpp ] [ -EL ] [ -EB ] [ -G num ]
 [ -mips1 ] [ -mips2 ] [ -mips3 ]
 [ --trap ] [ --break ]
 [ -- | files ... ]

 -a[dhlns]
           Turn on listings, in any of a variety of ways:

           -ad
                          omit debugging directives from listing

           -ah
                          include high-level source

           -al
                          assembly listing

           -an
                          no forms processing

           -as
                          symbols

           You may combine these options; for example, use `-aln' for assembly
           listing without forms processing.  By itself, `-a' defaults to
           `-ahls'---that is, all listings turned on.

 -D
           This option is accepted only for script compatibility with calls to
           other assemblers; it has no effect on as.

 -f
           ``fast''---skip whitespace and comment preprocessing (assume source
           is compiler output)

 -I path
           Add path to the search list for .include directives

 -K
           Issue warnings when difference tables altered for long
           displacements.

 -L
           Keep (in symbol table) local symbols, starting with `L'

 -o objfile
           Name the object-file output from as

 -R
           Fold data section into text section

 --statistics
           Display maximum space (in bytes), and total time (in seconds), taken
           by assembly.

 -v
           Announce as version

 -W
           Suppress warning messages

 -Z
           Generate object file even after errors

 -- | files ...
           Standard input, or source files to assemble.

 The following options are available when as is configured for the Intel 80960
 processor.

 -ACA | -ACA_A | -ACB | -ACC | -AKA | -AKB | -AKC | -AMC
           Specify which variant of the 960 architecture is the target.

 -b
           Add code to collect statistics about branches taken.

 -norelax
           Do not alter compare-and-branch instructions for long displacements;
           error if necessary.

 The following options are available when as is configured for the Motorola
 68000 series.

 -l
           Shorten references to undefined symbols, to one word instead of two.

 -m68000 | -m68008 | -m68010 | -m68020 | -m68030 | -m68040
 | -m68302 | -m68331 | -m68332 | -m68333 | -m68340 | -mcpu32
           Specify what processor in the 68000 family is the target.  The
           default is normally the 68020, but this can be changed at
           configuration time.

 -m68881 | -m68882 | - mno-68881 | -mno-68882
           The target machine does (or does not) have a floating-point
           coprocessor. The default is to assume a coprocessor for 68020,
           68030, and cpu32.  Although the basic 68000 is not compatible with
           the 68881, a combination of the two can be specified, since it's
           possible to do emulation of the coprocessor instructions with the
           main processor.

 -m68851 | -mno-68851
           The target machine does (or does not) have a memory-management unit
           coprocessor.  The default is to assume an MMU for 68020 and up.

 The following options are available when as is configured for the SPARC
 architecture:

 -Av6 | -Av7 | -Av8 | -Asparclite
           Explicitly select a variant of the SPARC architecture.

 -bump
           Warn when the assembler switches to another architecture.

 The following options are available when as is configured for a MIPS
 processor.

 -G num
           This option sets the largest size of an object that can be
           referenced implicitly with the gp register.  It is only accepted for
           targets that use ECOFF format, such as a DECstation running Ultrix.
           The default value is 8.

 -EB
           Generate ``big endian'' format output.

 -EL
           Generate ``little endian'' format output.

 -mips1
 -mips2
 -mips3
           Generate code for a particular MIPS Instruction Set Architecture
           level. `-mips1' corresponds to the r2000 and r3000 processors,
           `-mips2' to the r6000 processor, and `-mips3' to the r4000
           processor.

 -nocpp
           as ignores this option.  It is accepted for compatibility with the
           native tools.

 --trap
 --no-trap
 --break
 --no-break
           Control how to deal with multiplication overflow and division by
           zero. `--trap' or `--no-break' (which are synonyms) take a trap
           exception (and only work for Instruction Set Architecture level 2
           and higher); `--break' or `--no-trap' (also synonyms, and the
           default) take a break exception.

 Manual                                  Structure of this Manual
 GNU Assembler                           AS, the GNU Assembler
 Object Formats                          Object File Formats
 Command Line                            Command Line
 Input Files                             Input Files
 Object                                  Output (Object) File
 Errors                                  Error and Warning Messages


ΓòÉΓòÉΓòÉ 3.1. Structure of this Manual ΓòÉΓòÉΓòÉ

This manual is intended to describe what you need to know to use gnu as.  We
cover the syntax expected in source files, including notation for symbols,
constants, and expressions; the directives that as understands; and of course
how to invoke as.

This manual also describes some of the machine-dependent features of various
flavors of the assembler.

On the other hand, this manual is not intended as an introduction to
programming in assembly language---let alone programming in general! In a
similar vein, we make no attempt to introduce the machine architecture; we do
not describe the instruction set, standard mnemonics, registers or addressing
modes that are standard to a particular architecture. You may want to consult
the manufacturer's machine architecture manual for this information. For
information on the Hitachi SH machine instruction set, see SH-Microcomputer
User's Manual (Hitachi Micro Systems, Inc.). For information on the Z8000
machine instruction set, see Z8000 CPU Technical Manual


ΓòÉΓòÉΓòÉ 3.2. as, the GNU Assembler ΓòÉΓòÉΓòÉ

gnu as is really a family of assemblers. If you use (or have used) the gnu
assembler on one architecture, you should find a fairly similar environment
when you use it on another architecture.  Each version has much in common with
the others, including object file formats, most assembler directives (often
called pseudo-ops) and assembler syntax.

as is primarily intended to assemble the output of the gnu C compiler gcc for
use by the linker ld.  Nevertheless, we've tried to make as assemble correctly
everything that other assemblers for the same machine would assemble. Any
exceptions are documented explicitly (see Machine Dependencies). This doesn't
mean as always uses the same syntax as another assembler for the same
architecture; for example, we know of several incompatible versions of 680x0
assembly language syntax.

Unlike older assemblers, as is designed to assemble a source program in one
pass of the source file.  This has a subtle impact on the .org directive (see
.org).


ΓòÉΓòÉΓòÉ 3.3. Object File Formats ΓòÉΓòÉΓòÉ

The gnu assembler can be configured to produce several alternative object file
formats.  For the most part, this does not affect how you write assembly
language programs; but directives for debugging symbols are typically different
in different file formats. See Symbol Attributes. On the machine specific, as
can be configured to produce either a.out or COFF format object files. On the
machine specific, as can be configured to produce either b.out or COFF format
object files. On the machine specific, as can be configured to produce either
SOM or ELF format object files.


ΓòÉΓòÉΓòÉ 3.4. Command Line ΓòÉΓòÉΓòÉ

After the program name as, the command line may contain options and file names.
Options may appear in any order, and may be before, after, or between file
names.  The order of file names is significant.

`--' (two hyphens) by itself names the standard input file explicitly, as one
of the files for as to assemble.

Except for `--' any command line argument that begins with a hyphen (`-') is an
option.  Each option changes the behavior of as.  No option changes the way
another option works.  An option is a `-' followed by one or more letters; the
case of the letter is important.  All options are optional.

Some options expect exactly one file name to follow them.  The file name may
either immediately follow the option's letter (compatible with older
assemblers) or it may be the next command argument (gnu standard).  These two
command lines are equivalent:

as -o my-object-file.o mumble.s
as -omy-object-file.o mumble.s


ΓòÉΓòÉΓòÉ 3.5. Input Files ΓòÉΓòÉΓòÉ

We use the phrase source program, abbreviated source, to describe the program
input to one run of as.  The program may be in one or more files; how the
source is partitioned into files doesn't change the meaning of the source.

The source program is a concatenation of the text in all the files, in the
order specified.

Each time you run as it assembles exactly one source program.  The source
program is made up of one or more files. (The standard input is also a file.)

You give as a command line that has zero or more input file names.  The input
files are read (from left file name to right).  A command line argument (in any
position) that has no special meaning is taken to be an input file name.

If you give as no file names it attempts to read one input file from the as
standard input, which is normally your terminal.  You may have to type ctl-D to
tell as there is no more program to assemble.

Use `--' if you need to explicitly name the standard input file in your command
line.

If the source is empty, as produces a small, empty object file.

Filenames and Line-numbers

There are two ways of locating a line in the input file (or files) and either
may be used in reporting error messages.  One way refers to a line number in a
physical file; the other refers to a line number in a ``logical'' file.  See
Error and Warning Messages.

Physical files are those files named in the command line given to as.

Logical files are simply names declared explicitly by assembler directives;
they bear no relation to physical files.  Logical file names help error
messages reflect the original source file, when as source is itself synthesized
from other files. See .app-file.


ΓòÉΓòÉΓòÉ 3.6. Output (Object) File ΓòÉΓòÉΓòÉ

Every time you run as it produces an output file, which is your assembly
language program translated into numbers.  This file is the object file.  Its
default name is a.out, or b.out when as is configured for the Intel 80960. You
can give it another name by using the -o option.  Conventionally, object file
names end with `.o'.  The default name is used for historical reasons: older
assemblers were capable of assembling self-contained programs directly into a
runnable program.  (For some formats, this isn't currently possible, but it can
be done for the a.out format.)

The object file is meant for input to the linker ld.  It contains assembled
program code, information to help ld integrate the assembled program into a
runnable file, and (optionally) symbolic information for the debugger.


ΓòÉΓòÉΓòÉ 3.7. Error and Warning Messages ΓòÉΓòÉΓòÉ

as may write warnings and error messages to the standard error file (usually
your terminal).  This should not happen when  a compiler runs as automatically.
Warnings report an assumption made so that as could keep assembling a flawed
program; errors report a grave problem that stops the assembly.

Warning messages have the format

file_name:NNN:Warning Message Text

(where NNN is a line number).  If a logical file name has been given (see
.app-file) it is used for the filename, otherwise the name of the current input
file is used.  If a logical line number was given (see .line) (see .ln) then it
is used to calculate the number printed, otherwise the actual line in the
current source file is printed.  The message text is intended to be self
explanatory (in the grand Unix tradition).

Error messages have the format

file_name:NNN:FATAL:Error Message Text

The file name and line number are derived as for warning messages.  The actual
message text may be rather less explanatory because many of them aren't
supposed to happen.


ΓòÉΓòÉΓòÉ 4. Command-Line Options ΓòÉΓòÉΓòÉ

This chapter describes command-line options available in all versions of the
gnu assembler; see Machine Dependencies, for options specific to particular
machine architectures.

If you are invoking as via the gnu C compiler (version 2), you can use the
`-Wa' option to pass arguments through to the assembler.  The assembler
arguments must be separated from each other (and the `-Wa') by commas.  For
example:

gcc -c -g -O -Wa,-alh,-L file.c

emits a listing to standard output with high-level and assembly source.

Usually you do not need to use this `-Wa' mechanism, since many compiler
command-line options are automatically passed to the assembler by the compiler.
(You can call the gnu compiler driver with the `-v' option to see precisely
what options it passes to each compilation pass, including the assembler.)

 a                                       -a[dhlns] enable listings
 D                                       -D for compatibility
 f                                       -f to work faster
 I                                       -I for .include search path

 K                                       -K for compatibility

 K                                       -K for difference tables

 L                                       -L to retain local labels
 o                                       -o to name the object file
 R                                       -R to join data and text sections
 statistics                              --statistics to see statistics about
                                         assembly
 v                                       -v to announce version
 W                                       -W to suppress warnings
 Z                                       -Z to make object file even after
                                         errors


ΓòÉΓòÉΓòÉ 4.1. Enable Listings: -a[dhlns] ΓòÉΓòÉΓòÉ

These options enable listing output from the assembler.  By itself, `-a'
requests high-level, assembly, and symbols listing. You can use other letters
to select specific options for the list: `-ah' requests a high-level language
listing, `-al' requests an output-program assembly listing, and `-as' requests
a symbol table listing. High-level listings require that a compiler debugging
option like `-g' be used, and that assembly listings (`-al') be requested also.

Use the `-ad' option to omit debugging directives from the listing.

Once you have specified one of these options, you can further control listing
output and its appearance using the directives .list, .nolist, .psize, .eject,
.title, and .sbttl. The `-an' option turns off all forms processing. If you do
not request listing output with one of the `-a' options, the listing-control
directives have no effect.

The letters after `-a' may be combined into one option, e.g., `-aln'.


ΓòÉΓòÉΓòÉ 4.2. -D ΓòÉΓòÉΓòÉ

This option has no effect whatsoever, but it is accepted to make it more likely
that scripts written for other assemblers also work with as.


ΓòÉΓòÉΓòÉ 4.3. Work Faster: -f ΓòÉΓòÉΓòÉ

`-f' should only be used when assembling programs written by a (trusted)
compiler.  `-f' stops the assembler from doing whitespace and comment
preprocessing on the input file(s) before assembling them. See Preprocessing.

Warning: if you use `-f' when the files actually need to be preprocessed (if
they contain comments, for example), as does not work correctly.


ΓòÉΓòÉΓòÉ 4.4. .include search path: -I path ΓòÉΓòÉΓòÉ

Use this option to add a path to the list of directories as searches for files
specified in .include directives (see .include).  You may use -I as many times
as necessary to include a variety of paths.  The current working directory is
always searched first; after that, as searches any `-I' directories in the same
order as they were specified (left to right) on the command line.


ΓòÉΓòÉΓòÉ 4.5. Difference Tables: -K ΓòÉΓòÉΓòÉ

as sometimes alters the code emitted for directives of the form `.word
sym1-sym2'; see .word. You can use the `-K' option if you want a warning issued
when this is done.


ΓòÉΓòÉΓòÉ 4.6. Include Local Labels: -L ΓòÉΓòÉΓòÉ

Labels beginning with `L' (upper case only) are called local labels. See Symbol
Names.  Normally you do not see such labels when debugging, because they are
intended for the use of programs (like compilers) that compose assembler
programs, not for your notice. Normally both as and ld discard such labels, so
you do not normally debug with them.

This option tells as to retain those `L...' symbols in the object file.
Usually if you do this you also tell the linker ld to preserve symbols whose
names begin with `L'.

By default, a local label is any label beginning with `L', but each target is
allowed to redefine the local label prefix. On the HPPA local labels begin with
`L$'.


ΓòÉΓòÉΓòÉ 4.7. Name the Object File: -o ΓòÉΓòÉΓòÉ

There is always one object file output when you run as.  By default it has the
name `a.out' (or `b.out', for Intel 960 targets only). You use this option
(which takes exactly one filename) to give the object file a different name.

Whatever the object file is called, as overwrites any existing file of the same
name.


ΓòÉΓòÉΓòÉ 4.8. Join Data and Text Sections: -R ΓòÉΓòÉΓòÉ

-R tells as to write the object file as if all data-section data lives in the
text section.  This is only done at the very last moment:  your binary data are
the same, but data section parts are relocated differently.  The data section
part of your object file is zero bytes long because all its bytes are appended
to the text section.  (See Sections and Relocation.)

When you specify -R it would be possible to generate shorter address
displacements (because we do not have to cross between text and data section).
We refrain from doing this simply for compatibility with older versions of as.
In future, -R may work this way.

When as is configured for COFF output, this option is only useful if you use
sections named `.text' and `.data'.

-R is not supported for any of the HPPA targets.  Using -R generates a warning
from as.


ΓòÉΓòÉΓòÉ 4.9. Display Assembly Statistics: --statistics ΓòÉΓòÉΓòÉ

Use `--statistics' to display two statistics about the resources used by as:
the maximum amount of space allocated during the assembly (in bytes), and the
total execution time taken for the assembly (in cpu seconds).


ΓòÉΓòÉΓòÉ 4.10. Announce Version: -v ΓòÉΓòÉΓòÉ

You can find out what version of as is running by including the option `-v'
(which you can also spell as `-version') on the command line.


ΓòÉΓòÉΓòÉ 4.11. Suppress Warnings: -W ΓòÉΓòÉΓòÉ

as should never give a warning or error message when assembling compiler
output.  But programs written by people often cause as to give a warning that a
particular assumption was made.  All such warnings are directed to the standard
error file. If you use this option, no warnings are issued.  This option only
affects the warning messages: it does not change any particular of how as
assembles your file.  Errors, which stop the assembly, are still reported.


ΓòÉΓòÉΓòÉ 4.12. Generate Object File in Spite of Errors: -Z ΓòÉΓòÉΓòÉ

After an error message, as normally produces no output.  If for some reason you
are interested in object file output even after as gives an error message on
your program, use the `-Z' option.  If there are any errors, as continues
anyways, and writes an object file after a final warning message of the form `n
errors, m warnings, generating bad object file.'


ΓòÉΓòÉΓòÉ 5. Syntax ΓòÉΓòÉΓòÉ

This chapter describes the machine-independent syntax allowed in a source file.
as syntax is similar to what many other assemblers use; it is inspired by the
BSD 4.2 assembler, except that as does not assemble Vax bit-fields.

 Preprocessing                           Preprocessing
 Whitespace                              Whitespace
 Comments                                Comments
 Symbol Intro                            Symbols
 Statements                              Statements
 Constants                               Constants


ΓòÉΓòÉΓòÉ 5.1. Preprocessing ΓòÉΓòÉΓòÉ

The as internal preprocessor:

     adjusts and removes extra whitespace.  It leaves one space or tab before
      the keywords on a line, and turns any other whitespace on the line into a
      single space.

     removes all comments, replacing them with a single space, or an
      appropriate number of newlines.

     converts character constants into the appropriate numeric values.

 It does not do macro processing, include file handling, or anything else you
 may get from your C compiler's preprocessor.  You can do include file
 processing with the .include directive (see .include).  You can use the gnu C
 compiler driver to get other ``CPP'' style preprocessing, by giving the input
 file a `.S' suffix. See Options Controlling the Kind of Output.

 Excess whitespace, comments, and character constants cannot be used in the
 portions of the input text that are not preprocessed.

 If the first line of an input file is #NO_APP or if you use the `-f' option,
 whitespace and comments are not removed from the input file. Within an input
 file, you can ask for whitespace and comment removal in specific portions of
 the by putting a line that says #APP before the text that may contain
 whitespace or comments, and putting a line that says #NO_APP after this text.
 This feature is mainly intend to support asm statements in compilers whose
 output is otherwise free of comments and whitespace.


ΓòÉΓòÉΓòÉ 5.2. Whitespace ΓòÉΓòÉΓòÉ

Whitespace is one or more blanks or tabs, in any order. Whitespace is used to
separate symbols, and to make programs neater for people to read.  Unless
within character constants (see Character Constants), any whitespace means the
same as exactly one space.


ΓòÉΓòÉΓòÉ 5.3. Comments ΓòÉΓòÉΓòÉ

There are two ways of rendering comments to as.  In both cases the comment is
equivalent to one space.

Anything from `/*' through the next `*/' is a comment. This means you may not
nest these comments.

/*
  The only way to include a newline ('\n') in a comment
  is to use this sort of comment.
*/

/* This sort of comment does not nest. */

Anything from the line comment character to the next newline is considered a
comment and is ignored.  The line comment character is `#' on the Vax; `#' on
the i960; `!' on the SPARC; `|' on the 680x0; `;' for the AMD 29K family; `;'
for the H8/300 family; `!' for the H8/500 family; `;' for the HPPA; `!' for the
Hitachi SH; `!' for the Z8000; see Machine Dependencies.

On some machines there are two different line comment characters.  One
character only begins a comment if it is the first non-whitespace character on
a line, while the other always begins a comment.

To be compatible with past assemblers, lines that begin with `#' have a special
interpretation.  Following the `#' should be an absolute expression (see
Expressions): the logical line number of the next line.  Then a string (see
Strings) is allowed: if present it is a new logical file name.  The rest of the
line, if any, should be whitespace.

If the first non-whitespace characters on the line are not numeric, the line is
ignored.  (Just like a comment.)

                          # This is an ordinary comment.
# 42-6 "new_file_name"    # New logical file name
                          # This is logical line # 36.

This feature is deprecated, and may disappear from future versions of as.


ΓòÉΓòÉΓòÉ 5.4. Symbols ΓòÉΓòÉΓòÉ

A symbol is one or more characters chosen from the set of all letters (both
upper and lower case), digits and the three characters `_.$'. On most machines,
you can also use $ in symbol names; exceptions are noted in Machine
Dependencies. No symbol may begin with a digit.  Case is significant. There is
no length limit: all characters are significant.  Symbols are delimited by
characters not in that set, or by the beginning of a file (since the source
program must end with a newline, the end of a file is not a possible symbol
delimiter).  See Symbols.


ΓòÉΓòÉΓòÉ 5.5. Statements ΓòÉΓòÉΓòÉ

A statement ends at a newline character (`\n') or an exclamation point (`!').
The newline or exclamation point is considered part of the preceding statement.
Newlines and exclamation points within character constants are an exception:
they do not end statements. A statement ends at a newline character (`\n'); or
(for the H8/300) a dollar sign (`$'); or (for the Hitachi-SH or the H8/500) a
semicolon (`;').  The newline or separator character is considered part of the
preceding statement.  Newlines and separators within character constants are an
exception: they do not end statements. A statement ends at a newline character
(`\n') or line separator character.  (The line separator is usually `;', unless
this conflicts with the comment character; see Machine Dependencies.)  The
newline or separator character is considered part of the preceding statement.
Newlines and separators within character constants are an exception: they do
not end statements.

It is an error to end any statement with end-of-file:  the last character of
any input file should be a newline.

You may write a statement on more than one line if you put a backslash (\)
immediately in front of any newlines within the statement.  When as reads a
backslashed newline both characters are ignored.  You can even put backslashed
newlines in the middle of symbol names without changing the meaning of your
source program.

An empty statement is allowed, and may include whitespace.  It is ignored.

A statement begins with zero or more labels, optionally followed by a key
symbol which determines what kind of statement it is.  The key symbol
determines the syntax of the rest of the statement.  If the symbol begins with
a dot `.' then the statement is an assembler directive: typically valid for any
computer.  If the symbol begins with a letter the statement is an assembly
language instruction: it assembles into a machine language instruction.
Different versions of as for different computers recognize different
instructions.  In fact, the same symbol may represent a different instruction
in a different computer's assembly language.

A label is a symbol immediately followed by a colon (:). Whitespace before a
label or after a colon is permitted, but you may not have whitespace between a
label's symbol and its colon. See Labels.

For HPPA targets, labels need not be immediately followed by a colon, but the
definition of a label must begin in column zero.  This also implies that only
one label may be defined on each line.

label:     .directive    followed by something
another_label:           # This is an empty statement.
           instruction   operand_1, operand_2, ...


ΓòÉΓòÉΓòÉ 5.6. Constants ΓòÉΓòÉΓòÉ

A constant is a number, written so that its value is known by inspection,
without knowing any context.  Like this:

.byte  74, 0112, 092, 0x4A, 0X4a, 'J, '\J # All the same value.
.ascii "Ring the bell\7"                  # A string constant.
.octa  0x123456789abcdef0123456789ABCDEF0 # A bignum.
.float 0f-314159265358979323846264338327\
95028841971.693993751E-40                 # - pi, a flonum.

 Characters                              Character Constants
 Numbers                                 Number Constants


ΓòÉΓòÉΓòÉ 5.6.1. Character Constants ΓòÉΓòÉΓòÉ

There are two kinds of character constants.  A character stands for one
character in one byte and its value may be used in numeric expressions.  String
constants (properly called string literals) are potentially many bytes and
their values may not be used in arithmetic expressions.

 Strings                                 Strings
 Chars                                   Characters


ΓòÉΓòÉΓòÉ 5.6.1.1. Strings ΓòÉΓòÉΓòÉ

A string is written between double-quotes.  It may contain double-quotes or
null characters.  The way to get special characters into a string is to escape
these characters: precede them with a backslash `\' character.  For example
`\\' represents one backslash:  the first \ is an escape which tells as to
interpret the second character literally as a backslash (which prevents as from
recognizing the second \ as an escape character).  The complete list of escapes
follows.

 \b
           Mnemonic for backspace; for ASCII this is octal code 010.

 \f
           Mnemonic for FormFeed; for ASCII this is octal code 014.

 \n
           Mnemonic for newline; for ASCII this is octal code 012.

 \r
           Mnemonic for carriage-Return; for ASCII this is octal code 015.

 \t
           Mnemonic for horizontal Tab; for ASCII this is octal code 011.

 \ digit digit digit
           An octal character code.  The numeric code is 3 octal digits. For
           compatibility with other Unix systems, 8 and 9 are accepted as
           digits: for example, \008 has the value 010, and \009 the value 011.

 \x hex-digit hex-digit
           A hex character code.  The numeric code is 2 hexadecimal digits.
           Either upper or lower case x works.

 \\
           Represents one `\' character.

 \"
           Represents one `"' character.  Needed in strings to represent this
           character, because an unescaped `"' would end the string.

 \ anything-else
           Any other character when escaped by \ gives a warning, but assembles
           as if the `\' was not present.  The idea is that if you used an
           escape sequence you clearly didn't want the literal interpretation
           of the following character.  However as has no other interpretation,
           so as knows it is giving you the wrong code and warns you of the
           fact.

 Which characters are escapable, and what those escapes represent, varies
 widely among assemblers.  The current set is what we think the BSD 4.2
 assembler recognizes, and is a subset of what most C compilers recognize.  If
 you are in doubt, do not use an escape sequence.


ΓòÉΓòÉΓòÉ 5.6.1.2. Characters ΓòÉΓòÉΓòÉ

A single character may be written as a single quote immediately followed by
that character.  The same escapes apply to characters as to strings.  So if you
want to write the character backslash, you must write '\\ where the first \
escapes the second \.  As you can see, the quote is an acute accent, not a
grave accent.  A newline (or dollar sign `$', for the H8/300; or semicolon `;'
for the Hitachi SH or H8/500) immediately following an acute accent is taken as
a literal character and does not count as the end of a statement.  The value of
a character constant in a numeric expression is the machine's byte-wide code
for that character.  as assumes your character code is ASCII: 'A means 65, 'B
means 66, and so on.


ΓòÉΓòÉΓòÉ 5.6.2. Number Constants ΓòÉΓòÉΓòÉ

as distinguishes three kinds of numbers according to how they are stored in the
target machine.  Integers are numbers that would fit into an int in the C
language.  Bignums are integers, but they are stored in more than 32 bits.
Flonums are floating point numbers, described below.

 Integers                                Integers
 Bignums                                 Bignums
 Flonums                                 Flonums

 Bit Fields                              Bit Fields


ΓòÉΓòÉΓòÉ 5.6.2.1. Integers ΓòÉΓòÉΓòÉ

A binary integer is `0b' or `0B' followed by zero or more of the binary digits
`01'.

An octal integer is `0' followed by zero or more of the octal digits
(`01234567').

A decimal integer starts with a non-zero digit followed by zero or more digits
(`0123456789').

A hexadecimal integer is `0x' or `0X' followed by one or more hexadecimal
digits chosen from `0123456789abcdefABCDEF'.

Integers have the usual values.  To denote a negative integer, use the prefix
operator `-' discussed under expressions (see Prefix Operators).


ΓòÉΓòÉΓòÉ 5.6.2.2. Bignums ΓòÉΓòÉΓòÉ

A bignum has the same syntax and semantics as an integer except that the number
(or its negative) takes more than 32 bits to represent in binary.  The
distinction is made because in some places integers are permitted while bignums
are not.


ΓòÉΓòÉΓòÉ 5.6.2.3. Flonums ΓòÉΓòÉΓòÉ

A flonum represents a floating point number.  The translation is indirect: a
decimal floating point number from the text is converted by as to a generic
binary floating point number of more than sufficient precision.  This generic
floating point number is converted to a particular computer's floating point
format (or formats) by a portion of as specialized to that computer.

A flonum is written by writing (in order)

     The digit `0'. (`0' is optional on the HPPA.)

     A letter, to tell as the rest of the number is a flonum. e is
      recommended.  Case is not important.

      On the H8/300, H8/500, Hitachi SH, and AMD 29K architectures, the letter
      must be one of the letters `DFPRSX' (in upper or lower case).

      On the Intel 960 architecture, the letter must be one of the letters
      `DFT' (in upper or lower case).

      On the HPPA architecture, the letter must be `E' (upper case only). One
      of the letters `DFT' (in upper or lower case). The letter `E' (upper case
      only).

     An optional sign: either `+' or `-'.

     An optional integer part: zero or more decimal digits.

     An optional fractional part: `.' followed by zero or more decimal digits.

     An optional exponent, consisting of:

        -  An `E' or `e'.

        -  Optional sign: either `+' or `-'.

        -  One or more decimal digits.

 At least one of the integer part or the fractional part must be present.  The
 floating point number has the usual base-10 value.

 as does all processing using integers.  Flonums are computed independently of
 any floating point hardware in the computer running as. into a field whose
 width depends on which assembler directive has the

 bit-field as its argument.  Overflow (a result from the bitwise and requiring
 more binary digits to represent) is not an error; instead, more constants are
 generated, of the specified width, beginning with the least significant
 digits.

 The directives .byte, .hword, .int, .long, .short, and .word accept bit-field
 arguments.


ΓòÉΓòÉΓòÉ 6. Sections and Relocation ΓòÉΓòÉΓòÉ

 Secs Background                         Background
 Ld Sections                             LD Sections
 As Sections                             AS Internal Sections
 Sub-Sections                            Sub-Sections
 bss                                     bss Section


ΓòÉΓòÉΓòÉ 6.1. Background ΓòÉΓòÉΓòÉ

Roughly, a section is a range of addresses, with no gaps; all data ``in'' those
addresses is treated the same for some particular purpose. For example there
may be a ``read only'' section.

The linker ld reads many object files (partial programs) and combines their
contents to form a runnable program.  When as emits an object file, the partial
program is assumed to start at address 0. ld assigns the final addresses for
the partial program, so that different partial programs do not overlap.  This
is actually an oversimplification, but it suffices to explain how as uses
sections.

ld moves blocks of bytes of your program to their run-time addresses.  These
blocks slide to their run-time addresses as rigid units; their length does not
change and neither does the order of bytes within them.  Such a rigid unit is
called a section.  Assigning run-time addresses to sections is called
relocation.  It includes the task of adjusting mentions of object-file
addresses so they refer to the proper run-time addresses. For the H8/300 and
H8/500, and for the Hitachi SH, as pads sections if needed to ensure they end
on a word (sixteen bit) boundary.

An object file written by as has at least three sections, any of which may be
empty.  These are named text, data and bss sections.

When it generates COFF output, as can also generate whatever other named
sections you specify using the `.section' directive (see .section). If you do
not use any directives that place output in the `.text' or `.data' sections,
these sections still exist, but are empty.

When as generates SOM or ELF output for the HPPA, as can also generate whatever
other named sections you specify using the `.space' and `.subspace' directives.
See HP9000 Series 800 Assembly Language Reference Manual (HP 92432-90001) for
details on the `.space' and `.subspace' assembler directives.

Additionally, as uses different names for the standard text, data, and bss
sections when generating SOM output.  Program text is placed into the `$CODE$'
section, data into `$DATA$', and BSS into `$BSS$'.

Within the object file, the text section starts at address 0, the data section
follows, and the bss section follows the data section.

When generating either SOM or ELF output files on the HPPA, the text section
starts at address 0, the data section at address 0x4000000, and the bss section
follows the data section.

To let ld know which data changes when the sections are relocated, and how to
change that data, as also writes to the object file details of the relocation
needed.  To perform relocation ld must know, each time an address in the object
file is mentioned:

     Where in the object file is the beginning of this reference to an
      address?

     How long (in bytes) is this reference?

     Which section does the address refer to?  What is the numeric value of

            (address) - (start-address of section)?

     Is the reference to an address ``Program-Counter relative''?

 In fact, every address as ever uses is expressed as

  (section) + (offset into section)
 Further, most expressions as computes have this section-relative nature. (For
 some object formats, such as SOM for the HPPA, some expressions are
 symbol-relative instead.)

 In this manual we use the notation {secname N } to mean ``offset N into
 section secname.''

 Apart from text, data and bss sections you need to know about the absolute
 section.  When ld mixes partial programs, addresses in the absolute section
 remain unchanged.  For example, address {absolute 0} is ``relocated'' to
 run-time address 0 by ld.  Although the linker never arranges two partial
 programs' data sections with overlapping addresses after linking, by
 definition their absolute sections must overlap.  Address {absolute@ 239} in
 one part of a program is always the same address when the program is running
 as address {absolute@ 239} in any other part of the program.

 The idea of sections is extended to the undefined section.  Any address whose
 section is unknown at assembly time is by definition rendered {undefined
 U}---where U is filled in later. Since numbers are always defined, the only
 way to generate an undefined address is to mention an undefined symbol.  A
 reference to a named common block would be such a symbol: its value is unknown
 at assembly time so it has section undefined.

 By analogy the word section is used to describe groups of sections in the
 linked program.  ld puts all partial programs' text sections in contiguous
 addresses in the linked program.  It is customary to refer to the text section
 of a program, meaning all the addresses of all partial programs' text
 sections.  Likewise for data and bss sections.

 Some sections are manipulated by ld; others are invented for use of as and
 have no meaning except during assembly.


ΓòÉΓòÉΓòÉ 6.2. ld Sections ΓòÉΓòÉΓòÉ

ld deals with just four kinds of sections, summarized below.

 *named sections*
 *text section*
 *data section*
           These sections hold your program.  as and ld treat them as separate
           but equal sections.  Anything you can say of one section is true
           another. When the program is running, however, it is customary for
           the text section to be unalterable.  The text section is often
           shared among processes: it contains instructions, constants and the
           like.  The data section of a running program is usually alterable:
           for example, C variables would be stored in the data section.

 *bss section*
           This section contains zeroed bytes when your program begins running.
           It is used to hold unitialized variables or common storage.  The
           length of each partial program's bss section is important, but
           because it starts out containing zeroed bytes there is no need to
           store explicit zero bytes in the object file.  The bss section was
           invented to eliminate those explicit zeros from object files.

 *absolute section*
           Address 0 of this section is always ``relocated'' to runtime address
           0. This is useful if you want to refer to an address that ld must
           not change when relocating.  In this sense we speak of absolute
           addresses being ``unrelocatable'': they do not change during
           relocation.

 *undefined section*
           This ``section'' is a catch-all for address references to objects
           not in the preceding sections.

 An idealized example of three relocatable sections follows. The example uses
 the traditional section names `.text' and `.data'. Memory addresses are on the
 horizontal axis.

                        +-----+----+--+
  partial program # 1:  |ttttt|dddd|00|
                        +-----+----+--+

                        text   data bss
                        seg.   seg. seg.

                        +---+---+---+
  partial program # 2:  |TTT|DDD|000|
                        +---+---+---+

                        +--+---+-----+--+----+---+-----+~~
  linked program:       |  |TTT|ttttt|  |dddd|DDD|00000|
                        +--+---+-----+--+----+---+-----+~~

      addresses:        0 ...


ΓòÉΓòÉΓòÉ 6.3. as Internal Sections ΓòÉΓòÉΓòÉ

These sections are meant only for the internal use of as.  They have no meaning
at run-time.  You do not really need to know about these sections for most
purposes; but they can be mentioned in as warning messages, so it might be
helpful to have an idea of their meanings to as.  These sections are used to
permit the value of every expression in your assembly language program to be a
section-relative address.

 ASSEMBLER-INTERNAL-LOGIC-ERROR!
           An internal assembler logic error has been found.  This means there
           is a bug in the assembler.

 expr section
           The assembler stores complex expression internally as combinations
           of symbols.  When it needs to represent an expression as a symbol,
           it puts it in the expr section.


ΓòÉΓòÉΓòÉ 6.4. Sub-Sections ΓòÉΓòÉΓòÉ

Assembled bytes conventionally fall into two sections: text and data. You may
have separate groups of data in named sections text or data that you want to
end up near to each other in the object file, even though they are not
contiguous in the assembler source.  as allows you to use subsections for this
purpose.  Within each section, there can be numbered subsections with values
from 0 to 8192.  Objects assembled into the same subsection go into the object
file together with other objects in the same subsection.  For example, a
compiler might want to store constants in the text section, but might not want
to have them interspersed with the program being assembled.  In this case, the
compiler could issue a `.text 0' before each section of code being output, and
a `.text 1' before each group of constants being output.

Subsections are optional.  If you do not use subsections, everything goes in
subsection number zero.

Each subsection is zero-padded up to a multiple of four bytes. (Subsections may
be padded a different amount on different flavors of as.) On the AMD 29K
family, no particular padding is added to section or subsection sizes; as
forces no alignment on this platform.

Subsections appear in your object file in numeric order, lowest numbered to
highest.  (All this to be compatible with other people's assemblers.) The
object file contains no representation of subsections; ld and other programs
that manipulate object files see no trace of them. They just see all your text
subsections as a text section, and all your data subsections as a data section.

To specify which subsection you want subsequent statements assembled into, use
a numeric argument to specify it, in a `.text expression' or a `.data
expression' statement. When generating COFF output, you can also use an extra
subsection argument with arbitrary named sections: `.section name, expression'.
Expression should be an absolute expression. (See Expressions.)  If you just
say `.text' then `.text 0' is assumed.  Likewise `.data' means `.data 0'.
Assembly begins in text 0.  For instance:

.text 0     # The default subsection is text 0 anyway.
.ascii "This lives in the first text subsection. *"
.text 1
.ascii "But this lives in the second text subsection."
.data 0
.ascii "This lives in the data section,"
.ascii "in the first data subsection."
.text 0
.ascii "This lives in the first text section,"
.ascii "immediately following the asterisk (*)."

Each section has a location counter incremented by one for every byte assembled
into that section.  Because subsections are merely a convenience restricted to
as there is no concept of a subsection location counter.  There is no way to
directly manipulate a location counter---but the .align directive changes it,
and any label definition captures its current value.  The location counter of
the section where statements are being assembled is said to be the active
location counter.


ΓòÉΓòÉΓòÉ 6.5. bss Section ΓòÉΓòÉΓòÉ

The bss section is used for local common variable storage. You may allocate
address space in the bss section, but you may not dictate data to load into it
before your program executes.  When your program starts running, all the
contents of the bss section are zeroed bytes.

Addresses in the bss section are allocated with special directives; you may not
assemble anything directly into the bss section.  Hence there are no bss
subsections. See .comm, see .lcomm.


ΓòÉΓòÉΓòÉ 7. Symbols ΓòÉΓòÉΓòÉ

Symbols are a central concept: the programmer uses symbols to name things, the
linker uses symbols to link, and the debugger uses symbols to debug.

Warning: as does not place symbols in the object file in the same order they
were declared.  This may break some debuggers.

 Labels                                  Labels
 Setting Symbols                         Giving Symbols Other Values
 Symbol Names                            Symbol Names
 Dot                                     The Special Dot Symbol
 Symbol Attributes                       Symbol Attributes


ΓòÉΓòÉΓòÉ 7.1. Labels ΓòÉΓòÉΓòÉ

A label is written as a symbol immediately followed by a colon `:'.  The symbol
then represents the current value of the active location counter, and is, for
example, a suitable instruction operand.  You are warned if you use the same
symbol to represent two different locations: the first definition overrides any
other definitions.

On the HPPA, the usual form for a label need not be immediately followed by a
colon, but instead must start in column zero.  Only one label may be defined on
a single line.  To work around this, the HPPA version of as also provides a
special directive .label for defining labels more flexibly.


ΓòÉΓòÉΓòÉ 7.2. Giving Symbols Other Values ΓòÉΓòÉΓòÉ

A symbol can be given an arbitrary value by writing a symbol, followed by an
equals sign `=', followed by an expression (see Expressions).  This is
equivalent to using the .set directive.  See .set.


ΓòÉΓòÉΓòÉ 7.3. Symbol Names ΓòÉΓòÉΓòÉ

Symbol names begin with a letter or with one of `._'.  On most machines, you
can also use $ in symbol names; exceptions are noted in Machine Dependencies.
That character may be followed by any string of digits, letters, dollar signs
(unless otherwise noted in Machine Dependencies), and underscores. For the AMD
29K family, `?' is also allowed in the body of a symbol name, though not at its
beginning.

Case of letters is significant: foo is a different symbol name than Foo.

Each symbol has exactly one name.  Each name in an assembly language program
refers to exactly one symbol.  You may use that symbol name any number of times
in a program.

Local Symbol Names

Local symbols help compilers and programmers use names temporarily. There are
ten local symbol names, which are re-used throughout the program.  You may
refer to them using the names `0' `1' ... `9'.  To define a local symbol, write
a label of the form `N:' (where N represents any digit).  To refer to the most
recent previous definition of that symbol write `Nb', using the same digit as
when you defined the label.  To refer to the next definition of a local label,
write `Nf'---where N gives you a choice of 10 forward references.  The `b'
stands for ``backwards'' and the `f' stands for ``forwards''.

Local symbols are not emitted by the current gnu C compiler.

There is no restriction on how you can use these labels, but remember that at
any point in the assembly you can refer to at most 10 prior local labels and to
at most 10 forward local labels.

Local symbol names are only a notation device.  They are immediately
transformed into more conventional symbol names before the assembler uses them.
The symbol names stored in the symbol table, appearing in error messages and
optionally emitted to the object file have these parts:

 L
           All local labels begin with `L'. Normally both as and ld forget
           symbols that start with `L'. These labels are used for symbols you
           are never intended to see.  If you use the `-L' option then as
           retains these symbols in the object file. If you also instruct ld to
           retain these symbols, you may use them in debugging.

 digit
           If the label is written `0:' then the digit is `0'. If the label is
           written `1:' then the digit is `1'. And so on up through `9:'.

 ^A
           This unusual character is included so you do not accidentally invent
           a symbol of the same name.  The character has ASCII value `\001'.

 ordinal number
           This is a serial number to keep the labels distinct.  The first `0:'
           gets the number `1'; The 15th `0:' gets the number `15'; etc..
           Likewise for the other labels `1:' through `9:'.

 For instance, the first 1: is named L1^A1, the 44th 3: is named L3^A44.


ΓòÉΓòÉΓòÉ 7.4. The Special Dot Symbol ΓòÉΓòÉΓòÉ

The special symbol `.' refers to the current address that as is assembling
into.  Thus, the expression `melvin: .long .' defines melvin to contain its own
address. Assigning a value to . is treated the same as a .org directive.  Thus,
the expression `.=.+4' is the same as saying `.space 4'.


ΓòÉΓòÉΓòÉ 7.5. Symbol Attributes ΓòÉΓòÉΓòÉ

Every symbol has, as well as its name, the attributes ``Value'' and ``Type''.
Depending on output format, symbols can also have auxiliary attributes.

If you use a symbol without defining it, as assumes zero for all these
attributes, and probably won't warn you.  This makes the symbol an externally
defined symbol, which is generally what you would want.

 Symbol Value                            Value
 Symbol Type                             Type

 a.out Symbols                           Symbol Attributes: a.out

 a.out Symbols                           Symbol Attributes: a.out

 a.out Symbols                           Symbol Attributes: a.out, b.out

 COFF Symbols                            Symbol Attributes for COFF

 SOM Symbols                             Symbol Attributes for SOM


ΓòÉΓòÉΓòÉ 7.5.1. Value ΓòÉΓòÉΓòÉ

The value of a symbol is (usually) 32 bits.  For a symbol which labels a
location in the text, data, bss or absolute sections the value is the number of
addresses from the start of that section to the label. Naturally for text, data
and bss sections the value of a symbol changes as ld changes section base
addresses during linking.  Absolute symbols' values do not change during
linking: that is why they are called absolute.

The value of an undefined symbol is treated in a special way.  If it is 0 then
the symbol is not defined in this assembler source file, and ld tries to
determine its value from other files linked into the same program.  You make
this kind of symbol simply by mentioning a symbol name without defining it.  A
non-zero value represents a .comm common declaration.  The value is how much
common storage to reserve, in bytes (addresses).  The symbol refers to the
first address of the allocated storage.


ΓòÉΓòÉΓòÉ 7.5.2. Type ΓòÉΓòÉΓòÉ

The type attribute of a symbol contains relocation (section) information, any
flag settings indicating that a symbol is external, and (optionally), other
information for linkers and debuggers.  The exact format depends on the
object-code output format in use.


ΓòÉΓòÉΓòÉ 7.5.3. Symbol Attributes: a.out ΓòÉΓòÉΓòÉ

 Symbol Desc                             Descriptor
 Symbol Other                            Other


ΓòÉΓòÉΓòÉ 7.5.3.1. Descriptor ΓòÉΓòÉΓòÉ

This is an arbitrary 16-bit value.  You may establish a symbol's descriptor
value by using a .desc statement (see .desc).  A descriptor value means nothing
to as.


ΓòÉΓòÉΓòÉ 7.5.3.2. Other ΓòÉΓòÉΓòÉ

This is an arbitrary 8-bit value.  It means nothing to as.


ΓòÉΓòÉΓòÉ 7.5.4. Symbol Attributes for COFF ΓòÉΓòÉΓòÉ

The COFF format supports a multitude of auxiliary symbol attributes; like the
primary symbol attributes, they are set between .def and .endef directives.


ΓòÉΓòÉΓòÉ 7.5.4.1. Primary Attributes ΓòÉΓòÉΓòÉ

The symbol name is set with .def; the value and type, respectively, with .val
and .type.


ΓòÉΓòÉΓòÉ 7.5.4.2. Auxiliary Attributes ΓòÉΓòÉΓòÉ

The as directives .dim, .line, .scl, .size, and .tag can generate auxiliary
symbol table information for COFF.


ΓòÉΓòÉΓòÉ 7.5.5. Symbol Attributes for SOM ΓòÉΓòÉΓòÉ

The SOM format for the HPPA supports a multitude of symbol attributes set with
the .EXPORT and .IMPORT directives.

The attributes are described in HP9000 Series 800 Assembly Language Reference
Manual (HP 92432-90001) under the IMPORT and EXPORT assembler directive
documentation.


ΓòÉΓòÉΓòÉ 8. Expressions ΓòÉΓòÉΓòÉ

An expression specifies an address or numeric value. Whitespace may precede
and/or follow an expression.

The result of an expression must be an absolute number, or else an offset into
a particular section.  If an expression is not absolute, and there is not
enough information when as sees the expression to know its section, a second
pass over the source program might be necessary to interpret the
expression---but the second pass is currently not implemented. as aborts with
an error message in this situation.

 Empty Exprs                             Empty Expressions
 Integer Exprs                           Integer Expressions


ΓòÉΓòÉΓòÉ 8.1. Empty Expressions ΓòÉΓòÉΓòÉ

An empty expression has no value: it is just whitespace or null. Wherever an
absolute expression is required, you may omit the expression, and as assumes a
value of (absolute) 0.  This is compatible with other assemblers.


ΓòÉΓòÉΓòÉ 8.2. Integer Expressions ΓòÉΓòÉΓòÉ

An integer expression is one or more arguments delimited by operators.

 Arguments                               Arguments
 Operators                               Operators
 Prefix Ops                              Prefix Operators
 Infix Ops                               Infix Operators


ΓòÉΓòÉΓòÉ 8.2.1. Arguments ΓòÉΓòÉΓòÉ

Arguments are symbols, numbers or subexpressions.  In other contexts arguments
are sometimes called ``arithmetic operands''.  In this manual, to avoid
confusing them with the ``instruction operands'' of the machine language, we
use the term ``argument'' to refer to parts of expressions only, reserving the
word ``operand'' to refer only to machine instruction operands.

Symbols are evaluated to yield {section NNN} where section is one of text,
data, bss, absolute, or undefined.  NNN is a signed, 2's complement 32 bit
integer.

Numbers are usually integers.

A number can be a flonum or bignum.  In this case, you are warned that only the
low order 32 bits are used, and as pretends these 32 bits are an integer.  You
may write integer-manipulating instructions that act on exotic constants,
compatible with other assemblers.

Subexpressions are a left parenthesis `(' followed by an integer expression,
followed by a right parenthesis `)'; or a prefix operator followed by an
argument.


ΓòÉΓòÉΓòÉ 8.2.2. Operators ΓòÉΓòÉΓòÉ

Operators are arithmetic functions, like + or %.  Prefix operators are followed
by an argument.  Infix operators appear between their arguments.  Operators may
be preceded and/or followed by whitespace.


ΓòÉΓòÉΓòÉ 8.2.3. Prefix Operator ΓòÉΓòÉΓòÉ

as has the following prefix operators.  They each take one argument, which must
be absolute.

 -
           Negation.  Two's complement negation.

 ~
           Complementation.  Bitwise not.


ΓòÉΓòÉΓòÉ 8.2.4. Infix Operators ΓòÉΓòÉΓòÉ

Infix operators take two arguments, one on either side.  Operators have
precedence, but operations with equal precedence are performed left to right.
Apart from + or -, both arguments must be absolute, and the result is absolute.

   1. Highest Precedence

      *
                     Multiplication.

      /
                     Division.  Truncation is the same as the C operator `/'

      %
                     Remainder.

      <
      <<
                     Shift Left.  Same as the C operator `<<'.

      >
      >>
                     Shift Right.  Same as the C operator `>>'.

   2. Intermediate precedence

      |
                     Bitwise Inclusive Or.

      &
                     Bitwise And.

      ^
                     Bitwise Exclusive Or.

      !
                     Bitwise Or Not.

   3. Lowest Precedence

      +
                     Addition.  If either argument is absolute, the result has
                     the section of the other argument.  You may not add
                     together arguments from different sections.

      -
                     Subtraction.  If the right argument is absolute, the
                     result has the section of the left argument. If both
                     arguments are in the same section, the result is absolute.
                     You may not subtract arguments from different sections.

 In short, it's only meaningful to add or subtract the offsets in an address;
 you can only have a defined section in one of the two arguments.


ΓòÉΓòÉΓòÉ 9. Assembler Directives ΓòÉΓòÉΓòÉ

All assembler directives have names that begin with a period (`.'). The rest of
the name is letters, usually in lower case.

This chapter discusses directives that are available regardless of the target
machine configuration for the gnu assembler. Some machine configurations
provide additional directives. See Machine Dependencies.

 Abort                                   .abort

 ABORT                                   .ABORT

 Align                                   .align abs-expr , abs-expr
 App-File                                .app-file string
 Ascii                                   .ascii "string"
 Asciz                                   .asciz "string"
 Byte                                    .byte expressions
 Comm                                    .comm symbol , length
 Data                                    .data subsection

 Def                                     .def name

 Desc                                    .desc symbol, abs-expression

 Dim                                     .dim

 Double                                  .double flonums
 Eject                                   .eject
 Else                                    .else

 Endef                                   .endef

 Endif                                   .endif
 Equ                                     .equ symbol, expression
 Extern                                  .extern

 File                                    .file string

 Fill                                    .fill repeat , size , value
 Float                                   .float flonums
 Global                                  .global symbol, .globl symbol
 hword                                   .hword expressions
 Ident                                   .ident
 If                                      .if absolute expression
 Include                                 .include "file"
 Int                                     .int expressions
 Lcomm                                   .lcomm symbol , length
 Lflags                                  .lflags

 Line                                    .line line-number

 Ln                                      .ln line-number
 List                                    .list
 Long                                    .long expressions

 Lsym                                    .lsym symbol, expression

 Nolist                                  .nolist
 Octa                                    .octa bignums
 Org                                     .org new-lc , fill
 Psize                                   .psize lines, columns
 Quad                                    .quad bignums
 Sbttl                                   .sbttl "subheading"

 Scl                                     .scl class

 Section                                 .section name, subsection

 Set                                     .set symbol, expression
 Short                                   .short expressions
 Single                                  .single flonums

 Size                                    .size

 Space                                   .space size , fill

 Stab                                    .stabd, .stabn, .stabs

 String                                  .string "str"

 Tag                                     .tag structname

 Text                                    .text subsection
 Title                                   .title "heading"

 Type                                    .type int
 Val                                     .val addr

 Word                                    .word expressions
 Deprecated                              Deprecated Directives


ΓòÉΓòÉΓòÉ 9.1. .abort ΓòÉΓòÉΓòÉ

This directive stops the assembly immediately.  It is for compatibility with
other assemblers.  The original idea was that the assembly language source
would be piped into the assembler.  If the sender of the source quit, it could
use this directive tells as to quit also.  One day .abort will not be
supported.


ΓòÉΓòÉΓòÉ 9.2. .ABORT ΓòÉΓòÉΓòÉ

When producing COFF output, as accepts this directive as a synonym for
`.abort'.

When producing b.out output, as accepts this directive, but ignores it.


ΓòÉΓòÉΓòÉ 9.3. .align abs-expr , abs-expr ΓòÉΓòÉΓòÉ

Pad the location counter (in the current subsection) to a particular storage
boundary.  The first expression (which must be absolute) is the number of
low-order zero bits the location counter must have after advancement.  For
example `.align 3' advances the location counter until it a multiple of 8.  If
the location counter is already a multiple of 8, no change is needed.

For the HPPA, the first expression (which must be absolute) is the alignment
request in bytes.  For example `.align 8' advances the location counter until
it is a multiple of 8.  If the location counter is already a multiple of 8, no
change is needed.

The second expression (also absolute) gives the value to be stored in the
padding bytes.  It (and the comma) may be omitted.  If it is omitted, the
padding bytes are zero.


ΓòÉΓòÉΓòÉ 9.4. .app-file string ΓòÉΓòÉΓòÉ

.app-file (which may also be spelled `.file') tells as that we are about to
start a new logical file.  string is the new file name.  In general, the
filename is recognized whether or not it is surrounded by quotes `"'; but if
you wish to specify an empty file name is permitted, you must give the
quotes--"".  This statement may go away in future: it is only recognized to be
compatible with old as programs.


ΓòÉΓòÉΓòÉ 9.5. .ascii "string" ΓòÉΓòÉΓòÉ

.ascii expects zero or more string literals (see Strings) separated by commas.
It assembles each string (with no automatic trailing zero byte) into
consecutive addresses.


ΓòÉΓòÉΓòÉ 9.6. .asciz "string" ΓòÉΓòÉΓòÉ

.asciz is just like .ascii, but each string is followed by a zero byte.  The
``z'' in `.asciz' stands for ``zero''.


ΓòÉΓòÉΓòÉ 9.7. .byte expressions ΓòÉΓòÉΓòÉ

.byte expects zero or more expressions, separated by commas. Each expression is
assembled into the next byte.


ΓòÉΓòÉΓòÉ 9.8. .comm symbol , length ΓòÉΓòÉΓòÉ

.comm declares a named common area in the bss section.  Normally ld reserves
memory addresses for it during linking, so no partial program defines the
location of the symbol.  Use .comm to tell ld that it must be at least length
bytes long.  ld allocates space for each .comm symbol that is at least as long
as the longest .comm request in any of the partial programs linked.  length is
an absolute expression.

The syntax for .comm differs slightly on the HPPA.  The syntax is `symbol
.comm, length'; symbol is optional.


ΓòÉΓòÉΓòÉ 9.9. .data subsection ΓòÉΓòÉΓòÉ

.data tells as to assemble the following statements onto the end of the data
subsection numbered subsection (which is an absolute expression).  If
subsection is omitted, it defaults to zero.


ΓòÉΓòÉΓòÉ 9.10. .def name ΓòÉΓòÉΓòÉ

Begin defining debugging information for a symbol name; the definition extends
until the .endef directive is encountered.

This directive is only observed when as is configured for COFF format output;
when producing b.out, `.def' is recognized, but ignored.


ΓòÉΓòÉΓòÉ 9.11. .desc symbol, abs-expression ΓòÉΓòÉΓòÉ

This directive sets the descriptor of the symbol (see Symbol Attributes) to the
low 16 bits of an absolute expression.

The `.desc' directive is not available when as is configured for COFF output;
it is only for a.out or b.out object format.  For the sake of compatibility, as
accepts it, but produces no output, when configured for COFF.


ΓòÉΓòÉΓòÉ 9.12. .dim ΓòÉΓòÉΓòÉ

This directive is generated by compilers to include auxiliary debugging
information in the symbol table.  It is only permitted inside .def/.endef
pairs.

`.dim' is only meaningful when generating COFF format output; when as is
generating b.out, it accepts this directive but ignores it.


ΓòÉΓòÉΓòÉ 9.13. .double flonums ΓòÉΓòÉΓòÉ

.double expects zero or more flonums, separated by commas.  It assembles
floating point numbers. The exact kind of floating point numbers emitted
depends on how as is configured.  See Machine Dependencies.


ΓòÉΓòÉΓòÉ 9.14. .eject ΓòÉΓòÉΓòÉ

Force a page break at this point, when generating assembly listings.


ΓòÉΓòÉΓòÉ 9.15. .else ΓòÉΓòÉΓòÉ

.else is part of the as support for conditional assembly; see .if.  It marks
the beginning of a section of code to be assembled if the condition for the
preceding .if was false.


ΓòÉΓòÉΓòÉ 9.16. .endef ΓòÉΓòÉΓòÉ

This directive flags the end of a symbol definition begun with .def.

`.endef' is only meaningful when generating COFF format output; if as is
configured to generate b.out, it accepts this directive but ignores it.


ΓòÉΓòÉΓòÉ 9.17. .endif ΓòÉΓòÉΓòÉ

.endif is part of the as support for conditional assembly; it marks the end of
a block of code that is only assembled conditionally.  See .if.


ΓòÉΓòÉΓòÉ 9.18. .equ symbol, expression ΓòÉΓòÉΓòÉ

This directive sets the value of symbol to expression. It is synonymous with
`.set'; see .set.

The syntax for equ on the HPPA is `symbol .equ expression'.


ΓòÉΓòÉΓòÉ 9.19. .extern ΓòÉΓòÉΓòÉ

.extern is accepted in the source program---for compatibility with other
assemblers---but it is ignored.  as treats all undefined symbols as external.


ΓòÉΓòÉΓòÉ 9.20. .file string ΓòÉΓòÉΓòÉ

.file (which may also be spelled `.app-file') tells as that we are about to
start a new logical file. string is the new file name.  In general, the
filename is recognized whether or not it is surrounded by quotes `"'; but if
you wish to specify an empty file name, you must give the quotes--"".  This
statement may go away in future: it is only recognized to be compatible with
old as programs. In some configurations of as, .file has already been removed
to avoid conflicts with other assemblers.  See Machine Dependencies.


ΓòÉΓòÉΓòÉ 9.21. .fill repeat , size , value ΓòÉΓòÉΓòÉ

result, size and value are absolute expressions. This emits repeat copies of
size bytes.  Repeat may be zero or more.  Size may be zero or more, but if it
is more than 8, then it is deemed to have the value 8, compatible with other
people's assemblers.  The contents of each repeat bytes is taken from an 8-byte
number.  The highest order 4 bytes are zero.  The lowest order 4 bytes are
value rendered in the byte-order of an integer on the computer as is assembling
for. Each size bytes in a repetition is taken from the lowest order size bytes
of this number.  Again, this bizarre behavior is compatible with other people's
assemblers.

size and value are optional. If the second comma and value are absent, value is
assumed zero.  If the first comma and following tokens are absent, size is
assumed to be 1.


ΓòÉΓòÉΓòÉ 9.22. .float flonums ΓòÉΓòÉΓòÉ

This directive assembles zero or more flonums, separated by commas.  It has the
same effect as .single. The exact kind of floating point numbers emitted
depends on how as is configured. See Machine Dependencies.


ΓòÉΓòÉΓòÉ 9.23. .global symbol, .globl symbol ΓòÉΓòÉΓòÉ

.global makes the symbol visible to ld.  If you define symbol in your partial
program, its value is made available to other partial programs that are linked
with it.  Otherwise, symbol takes its attributes from a symbol of the same name
from another file linked into the same program.

Both spellings (`.globl' and `.global') are accepted, for compatibility with
other assemblers.

On the HPPA, .global is not always enough to make it accessible to other
partial programs.  You may need the HPPA-only .EXPORT directive as well. See
HPPA Assembler Directives.


ΓòÉΓòÉΓòÉ 9.24. .hword expressions ΓòÉΓòÉΓòÉ

This expects zero or more expressions, and emits a 16 bit number for each.

This directive is a synonym for `.short'; depending on the target architecture,
it may also be a synonym for `.word'.


ΓòÉΓòÉΓòÉ 9.25. .ident ΓòÉΓòÉΓòÉ

This directive is used by some assemblers to place tags in object files. as
simply accepts the directive for source-file compatibility with such
assemblers, but does not actually emit anything for it.


ΓòÉΓòÉΓòÉ 9.26. .if absolute expression ΓòÉΓòÉΓòÉ

.if marks the beginning of a section of code which is only considered part of
the source program being assembled if the argument (which must be an absolute
expression) is non-zero.  The end of the conditional section of code must be
marked by .endif (see .endif); optionally, you may include code for the
alternative condition, flagged by .else (see .else.

The following variants of .if are also supported:

 .ifdef symbol
           Assembles the following section of code if the specified symbol has
           been defined.

 .ifndef symbol
 ifnotdef symbol
           Assembles the following section of code if the specified symbol has
           not been defined.  Both spelling variants are equivalent.


ΓòÉΓòÉΓòÉ 9.27. .include "file" ΓòÉΓòÉΓòÉ

This directive provides a way to include supporting files at specified points
in your source program.  The code from file is assembled as if it followed the
point of the .include; when the end of the included file is reached, assembly
of the original file continues.  You can control the search paths used with the
`-I' command-line option (see Command-Line Options).  Quotation marks are
required around file.


ΓòÉΓòÉΓòÉ 9.28. .int expressions ΓòÉΓòÉΓòÉ

Expect zero or more expressions, of any section, separated by commas. For each
expression, emit a number that, at run time, is the value of that expression.
The byte order and bit size of the number depends on what kind of target the
assembly is for.


ΓòÉΓòÉΓòÉ 9.29. .lcomm symbol , length ΓòÉΓòÉΓòÉ

Reserve length (an absolute expression) bytes for a local common denoted by
symbol.  The section and value of symbol are those of the new local common.
The addresses are allocated in the bss section, so that at run-time the bytes
start off zeroed.  Symbol is not declared global (see .global), so is normally
not visible to ld.

The syntax for .lcomm differs slightly on the HPPA.  The syntax is `symbol
.lcomm, length'; symbol is optional.


ΓòÉΓòÉΓòÉ 9.30. .lflags ΓòÉΓòÉΓòÉ

as accepts this directive, for compatibility with other assemblers, but ignores
it.


ΓòÉΓòÉΓòÉ 9.31. .line line-number ΓòÉΓòÉΓòÉ

Change the logical line number.  line-number must be an absolute expression.
The next line has that logical line number.  Therefore any other statements on
the current line (after a statement separator character) are reported as on
logical line number line-number - 1.  One day as will no longer support this
directive: it is recognized only for compatibility with existing assembler
programs.

Warning: In the AMD29K configuration of as, this command is not available; use
the synonym .ln in that context.

Even though this is a directive associated with the a.out or b.out object-code
formats, as still recognizes it when producing COFF output, and treats `.line'
as though it were the COFF `.ln' if it is found outside a .def/.endef pair.

Inside a .def, `.line' is, instead, one of the directives used by compilers to
generate auxiliary symbol information for debugging.


ΓòÉΓòÉΓòÉ 9.32. .ln line-number ΓòÉΓòÉΓòÉ

`.ln' is a synonym for `.line'.


ΓòÉΓòÉΓòÉ 9.33. .list ΓòÉΓòÉΓòÉ

Control (in conjunction with the .nolist directive) whether or not assembly
listings are generated.  These two directives maintain an internal counter
(which is zero initially).  .list increments the counter, and .nolist
decrements it.  Assembly listings are generated whenever the counter is greater
than zero.

By default, listings are disabled.  When you enable them (with the `-a' command
line option; see Command-Line Options), the initial value of the listing
counter is one.


ΓòÉΓòÉΓòÉ 9.34. .long expressions ΓòÉΓòÉΓòÉ

.long is the same as `.int', see .int.


ΓòÉΓòÉΓòÉ 9.35. .nolist ΓòÉΓòÉΓòÉ

Control (in conjunction with the .list directive) whether or not assembly
listings are generated.  These two directives maintain an internal counter
(which is zero initially).  .list increments the counter, and .nolist
decrements it.  Assembly listings are generated whenever the counter is greater
than zero.


ΓòÉΓòÉΓòÉ 9.36. .octa bignums ΓòÉΓòÉΓòÉ

This directive expects zero or more bignums, separated by commas.  For each
bignum, it emits a 16-byte integer.

The term ``octa'' comes from contexts in which a ``word'' is two bytes; hence
octa-word for 16 bytes.


ΓòÉΓòÉΓòÉ 9.37. .org new-lc , fill ΓòÉΓòÉΓòÉ

Advance the location counter of the current section to new-lc.  new-lc is
either an absolute expression or an expression with the same section as the
current subsection.  That is, you can't use .org to cross sections: if new-lc
has the wrong section, the .org directive is ignored.  To be compatible with
former assemblers, if the section of new-lc is absolute, as issues a warning,
then pretends the section of new-lc is the same as the current subsection.

.org may only increase the location counter, or leave it unchanged; you cannot
use .org to move the location counter backwards.

Because as tries to assemble programs in one pass, new-lc may not be undefined.
If you really detest this restriction we eagerly await a chance to share your
improved assembler.

Beware that the origin is relative to the start of the section, not to the
start of the subsection.  This is compatible with other people's assemblers.

When the location counter (of the current subsection) is advanced, the
intervening bytes are filled with fill which should be an absolute expression.
If the comma and fill are omitted, fill defaults to zero.


ΓòÉΓòÉΓòÉ 9.38. .psize lines , columns ΓòÉΓòÉΓòÉ

Use this directive to declare the number of lines---and, optionally, the number
of columns---to use for each page, when generating listings.

If you do not use .psize, listings use a default line-count of 60.  You may
omit the comma and columns specification; the default width is 200 columns.

as generates formfeeds whenever the specified number of lines is exceeded (or
whenever you explicitly request one, using .eject).

If you specify lines as 0, no formfeeds are generated save those explicitly
specified with .eject.


ΓòÉΓòÉΓòÉ 9.39. .quad bignums ΓòÉΓòÉΓòÉ

.quad expects zero or more bignums, separated by commas.  For each bignum, it
emits an 8-byte integer.  If the bignum won't fit in 8 bytes, it prints a
warning message; and just takes the lowest order 8 bytes of the bignum.

The term ``quad'' comes from contexts in which a ``word'' is two bytes; hence
quad-word for 8 bytes.


ΓòÉΓòÉΓòÉ 9.40. .sbttl "subheading" ΓòÉΓòÉΓòÉ

Use subheading as the title (third line, immediately after the title line) when
generating assembly listings.

This directive affects subsequent pages, as well as the current page if it
appears within ten lines of the top of a page.


ΓòÉΓòÉΓòÉ 9.41. .scl class ΓòÉΓòÉΓòÉ

Set the storage-class value for a symbol.  This directive may only be used
inside a .def/.endef pair.  Storage class may flag whether a symbol is static
or external, or it may record further symbolic debugging information.

The `.scl' directive is primarily associated with COFF output; when configured
to generate b.out output format, as accepts this directive but ignores it.


ΓòÉΓòÉΓòÉ 9.42. .section name, subsection ΓòÉΓòÉΓòÉ

Assemble the following code into end of subsection numbered subsection in the
COFF named section name.  If you omit subsection, as uses subsection number
zero. `.section .text' is equivalent to the .text directive; `.section .data'
is equivalent to the .data directive.


ΓòÉΓòÉΓòÉ 9.43. .set symbol, expression ΓòÉΓòÉΓòÉ

Set the value of symbol to expression.  This changes symbol's value and type to
conform to expression.  If symbol was flagged as external, it remains flagged.
(See Symbol Attributes.)

You may .set a symbol many times in the same assembly.

If you .set a global symbol, the value stored in the object file is the last
value stored into it.

The syntax for set on the HPPA is `symbol .set expression'.


ΓòÉΓòÉΓòÉ 9.44. .short expressions ΓòÉΓòÉΓòÉ

.short is normally the same as `.word'. See .word.

In some configurations, however, .short and .word generate numbers of different
lengths; see Machine Dependencies.


ΓòÉΓòÉΓòÉ 9.45. .single flonums ΓòÉΓòÉΓòÉ

This directive assembles zero or more flonums, separated by commas.  It has the
same effect as .float. The exact kind of floating point numbers emitted depends
on how as is configured.  See Machine Dependencies.


ΓòÉΓòÉΓòÉ 9.46. .size ΓòÉΓòÉΓòÉ

This directive is generated by compilers to include auxiliary debugging
information in the symbol table.  It is only permitted inside .def/.endef
pairs.

`.size' is only meaningful when generating COFF format output; when as is
generating b.out, it accepts this directive but ignores it.


ΓòÉΓòÉΓòÉ 9.47. .space size , fill ΓòÉΓòÉΓòÉ

This directive emits size bytes, each of value fill.  Both size and fill are
absolute expressions.  If the comma and fill are omitted, fill is assumed to be
zero.

Warning: .space has a completely different meaning for HPPA targets; use .block
as a substitute.  See HP9000 Series 800 Assembly Language Reference Manual (HP
92432-90001) for the meaning of the .space directive.  See HPPA Assembler
Directives, for a summary. On the AMD 29K, this directive is ignored; it is
accepted for

compatibility with other AMD 29K assemblers.

Warning: In most versions of the gnu assembler, the directive .space has the
effect of .block  See Machine Dependencies.


ΓòÉΓòÉΓòÉ 9.48. .stabd, .stabn, .stabs ΓòÉΓòÉΓòÉ

There are three directives that begin `.stab'. All emit symbols (see Symbols),
for use by symbolic debuggers. The symbols are not entered in the as hash
table: they cannot be referenced elsewhere in the source file. Up to five
fields are required:

 string
           This is the symbol's name.  It may contain any character except
           `\000', so is more general than ordinary symbol names.  Some
           debuggers used to code arbitrarily complex structures into symbol
           names using this field.

 type
           An absolute expression.  The symbol's type is set to the low 8 bits
           of this expression.  Any bit pattern is permitted, but ld and
           debuggers choke on silly bit patterns.

 other
           An absolute expression.  The symbol's ``other'' attribute is set to
           the low 8 bits of this expression.

 desc
           An absolute expression.  The symbol's descriptor is set to the low
           16 bits of this expression.

 value
           An absolute expression which becomes the symbol's value.

 If a warning is detected while reading a .stabd, .stabn, or .stabs statement,
 the symbol has probably already been created; you get a half-formed symbol in
 your object file.  This is compatible with earlier assemblers!

 .stabd type , other , desc
           The ``name'' of the symbol generated is not even an empty string. It
           is a null pointer, for compatibility.  Older assemblers used a null
           pointer so they didn't waste space in object files with empty
           strings.

           The symbol's value is set to the location counter, relocatably.
           When your program is linked, the value of this symbol is the address
           of the location counter when the .stabd was assembled.

 .stabn type , other , desc , value
           The name of the symbol is set to the empty string "".

 .stabs string ,  type , other , desc , value
           All five fields are specified.


ΓòÉΓòÉΓòÉ 9.49. .string "str" ΓòÉΓòÉΓòÉ

Copy the characters in str to the object file.  You may specify more than one
string to copy, separated by commas.  Unless otherwise specified for a
particular machine, the assembler marks the end of each string with a 0 byte.
You can use any of the escape sequences described in Strings.


ΓòÉΓòÉΓòÉ 9.50. .tag structname ΓòÉΓòÉΓòÉ

This directive is generated by compilers to include auxiliary debugging
information in the symbol table.  It is only permitted inside .def/.endef
pairs.  Tags are used to link structure definitions in the symbol table with
instances of those structures.

`.tag' is only used when generating COFF format output; when as is generating
b.out, it accepts this directive but ignores it.


ΓòÉΓòÉΓòÉ 9.51. .text subsection ΓòÉΓòÉΓòÉ

Tells as to assemble the following statements onto the end of the text
subsection numbered subsection, which is an absolute expression.  If subsection
is omitted, subsection number zero is used.


ΓòÉΓòÉΓòÉ 9.52. .title "heading" ΓòÉΓòÉΓòÉ

Use heading as the title (second line, immediately after the source file name
and pagenumber) when generating assembly listings.

This directive affects subsequent pages, as well as the current page if it
appears within ten lines of the top of a page.


ΓòÉΓòÉΓòÉ 9.53. .type int ΓòÉΓòÉΓòÉ

This directive, permitted only within .def/.endef pairs, records the integer
int as the type attribute of a symbol table entry.

`.type' is associated only with COFF format output; when as is configured for
b.out output, it accepts this directive but ignores it.


ΓòÉΓòÉΓòÉ 9.54. .val addr ΓòÉΓòÉΓòÉ

This directive, permitted only within .def/.endef pairs, records the address
addr as the value attribute of a symbol table entry.

`.val' is used only for COFF output; when as is configured for b.out, it
accepts this directive but ignores it.


ΓòÉΓòÉΓòÉ 9.55. .word expressions ΓòÉΓòÉΓòÉ

This directive expects zero or more expressions, of any section, separated by
commas.

The size of the number emitted, and its byte order, depend on what target
computer the assembly is for.

Warning: Special Treatment to support Compilers

Machines with a 32-bit address space, but that do less than 32-bit addressing,
require the following special treatment.  If the machine of interest to you
does 32-bit addressing (or doesn't require it; see Machine Dependencies), you
can ignore this issue.

In order to assemble compiler output into something that works, as occasionlly
does strange things to `.word' directives. Directives of the form `.word
sym1-sym2' are often emitted by compilers as part of jump tables.  Therefore,
when as assembles a directive of the form `.word sym1-sym2', and the difference
between sym1 and sym2 does not fit in 16 bits, as creates a secondary jump
table, immediately before the next label. This secondary jump table is preceded
by a short-jump to the first byte after the secondary table.  This short-jump
prevents the flow of control from accidentally falling into the new table.
Inside the table is a long-jump to sym2.  The original `.word' contains sym1
minus the address of the long-jump to sym2.

If there were several occurrences of `.word sym1-sym2' before the secondary
jump table, all of them are adjusted.  If there was a `.word sym3-sym4', that
also did not fit in sixteen bits, a long-jump to sym4 is included in the
secondary jump table, and the .word directives are adjusted to contain sym3
minus the address of the long-jump to sym4; and so on, for as many entries in
the original jump table as necessary.


ΓòÉΓòÉΓòÉ 9.56. Deprecated Directives ΓòÉΓòÉΓòÉ

One day these directives won't work. They are included for compatibility with
older assemblers.

 .abort

 .app-file

 .line


ΓòÉΓòÉΓòÉ 10. Machine Dependent Features ΓòÉΓòÉΓòÉ

The machine instruction sets are (almost by definition) different on each
machine where as runs.  Floating point representations vary as well, and as
often supports a few additional directives or command-line options for
compatibility with other assemblers on a particular platform.  Finally, some
versions of as support special pseudo-instructions for branch optimization.

This chapter discusses most of these differences, though it does not include
details on any machine's instruction set.  For details on that subject, see the
hardware manufacturer's manual.

 Vax-Dependent                           VAX Dependent Features

 AMD29K-Dependent                        AMD 29K Dependent Features

 H8/300-Dependent                        Hitachi H8/300 Dependent Features

 H8/500-Dependent                        Hitachi H8/500 Dependent Features

 HPPA-Dependent                          HPPA Dependent Features

 SH-Dependent                            Hitachi SH Dependent Features

 i960-Dependent                          Intel 80960 Dependent Features

 M68K-Dependent                          M680x0 Dependent Features

 Sparc-Dependent                         SPARC Dependent Features

 Z8000-Dependent                         Z8000 Dependent Features

 MIPS-Dependent                          MIPS Dependent Features

 i386-Dependent                          80386 Dependent Features


ΓòÉΓòÉΓòÉ 11. VAX Dependent Features ΓòÉΓòÉΓòÉ

 Vax-Opts                                VAX Command-Line Options


 VAX-float                               VAX Floating Point
 VAX-directives                          Vax Machine Directives
 VAX-opcodes                             VAX Opcodes
 VAX-branch                              VAX Branch Improvement
 VAX-operands                            VAX Operands
 VAX-no                                  Not Supported on VAX


ΓòÉΓòÉΓòÉ 11.1. VAX Command-Line Options ΓòÉΓòÉΓòÉ

The Vax version of as accepts any of the following options, gives a warning
message that the option was ignored and proceeds. These options are for
compatibility with scripts designed for other people's assemblers.

 -D (Debug)
 -S (Symbol Table)
 -T (Token Trace)
           These are obsolete options used to debug old assemblers.

 -d (Displacement size for JUMPs)
           This option expects a number following the `-d'.  Like options that
           expect filenames, the number may immediately follow the `-d' (old
           standard) or constitute the whole of the command line argument that
           follows `-d' (gnu standard).

 -V (Virtualize Interpass Temporary File)
           Some other assemblers use a temporary file.  This option commanded
           them to keep the information in active memory rather than in a disk
           file.  as always does this, so this option is redundant.

 -J (JUMPify Longer Branches)
           Many 32-bit computers permit a variety of branch instructions to do
           the same job.  Some of these instructions are short (and fast) but
           have a limited range; others are long (and slow) but can branch
           anywhere in virtual memory.  Often there are 3 flavors of branch:
           short, medium and long.  Some other assemblers would emit short and
           medium branches, unless told by this option to emit short and long
           branches.

 -t (Temporary File Directory)
           Some other assemblers may use a temporary file, and this option
           takes a filename being the directory to site the temporary file.
           Since as does not use a temporary disk file, this option makes no
           difference.  `-t' needs exactly one filename.

 The Vax version of the assembler accepts two options when compiled for VMS.
 They are `-h', and `-+'.  The `-h' option prevents as from modifying the
 symbol-table entries for symbols that contain lowercase characters (I think).
 The `-+' option causes as to print warning messages if the FILENAME part of
 the object file, or any symbol name is larger than 31 characters.  The `-+'
 option also inserts some code following the `_main' symbol so that the object
 file is compatible with Vax-11 "C".


ΓòÉΓòÉΓòÉ 11.2. VAX Floating Point ΓòÉΓòÉΓòÉ

Conversion of flonums to floating point is correct, and compatible with
previous assemblers.  Rounding is towards zero if the remainder is exactly half
the least significant bit.

D, F, G and H floating point formats are understood.

Immediate floating literals (e.g. `S`$6.9') are rendered correctly.  Again,
rounding is towards zero in the boundary case.

The .float directive produces f format numbers. The .double directive produces
d format numbers.


ΓòÉΓòÉΓòÉ 11.3. Vax Machine Directives ΓòÉΓòÉΓòÉ

The Vax version of the assembler supports four directives for generating Vax
floating point constants.  They are described in the table below.

 .dfloat
           This expects zero or more flonums, separated by commas, and
           assembles Vax d format 64-bit floating point constants.

 .ffloat
           This expects zero or more flonums, separated by commas, and
           assembles Vax f format 32-bit floating point constants.

 .gfloat
           This expects zero or more flonums, separated by commas, and
           assembles Vax g format 64-bit floating point constants.

 .hfloat
           This expects zero or more flonums, separated by commas, and
           assembles Vax h format 128-bit floating point constants.


ΓòÉΓòÉΓòÉ 11.4. VAX Opcodes ΓòÉΓòÉΓòÉ

All DEC mnemonics are supported.  Beware that case... instructions have exactly
3 operands.  The dispatch table that follows the case... instruction should be
made with .word statements.  This is compatible with all unix assemblers we
know of.


ΓòÉΓòÉΓòÉ 11.5. VAX Branch Improvement ΓòÉΓòÉΓòÉ

Certain pseudo opcodes are permitted.  They are for branch instructions.  They
expand to the shortest branch instruction that reaches the target.  Generally
these mnemonics are made by substituting `j' for `b' at the start of a DEC
mnemonic. This feature is included both for compatibility and to help
compilers.  If you do not need this feature, avoid these opcodes.  Here are the
mnemonics, and the code they can expand into.

 jbsb
           `Jsb' is already an instruction mnemonic, so we chose `jbsb'.

           (byte displacement)
                          bsbb ...

           (word displacement)
                          bsbw ...

           (long displacement)
                          jsb ...

 jbr
 jr
           Unconditional branch.

           (byte displacement)
                          brb ...

           (word displacement)
                          brw ...

           (long displacement)
                          jmp ...

 jCOND
           COND may be any one of the conditional branches neq, nequ, eql,
           eqlu, gtr, geq, lss, gtru, lequ, vc, vs, gequ, cc, lssu, cs. COND
           may also be one of the bit tests bs, bc, bss, bcs, bsc, bcc, bssi,
           bcci, lbs, lbc. NOTCOND is the opposite condition to COND.

           (byte displacement)
                          bCOND ...

           (word displacement)
                          bNOTCOND foo ; brw ... ; foo:

           (long displacement)
                          bNOTCOND foo ; jmp ... ; foo:

 jacbX
           X may be one of b d f g h l w.

           (word displacement)
                          OPCODE ...

           (long displacement)

                      OPCODE ..., foo ;
                      brb bar ;
                      foo: jmp ... ;
                      bar:

 jaobYYY
           YYY may be one of lss leq.

 jsobZZZ
           ZZZ may be one of geq gtr.

           (byte displacement)
                          OPCODE ...

           (word displacement)

                      OPCODE ..., foo ;
                      brb bar ;
                      foo: brw destination ;
                      bar:

           (long displacement)

                      OPCODE ..., foo ;
                      brb bar ;
                      foo: jmp destination ;
                      bar:

 aobleq
 aoblss
 sobgeq
 sobgtr

           (byte displacement)
                          OPCODE ...

           (word displacement)

                      OPCODE ..., foo ;
                      brb bar ;
                      foo: brw destination ;
                      bar:

           (long displacement)

                      OPCODE ..., foo ;
                      brb bar ;
                      foo: jmp destination ;
                      bar:


ΓòÉΓòÉΓòÉ 11.6. VAX Operands ΓòÉΓòÉΓòÉ

The immediate character is `$' for Unix compatibility, not `#' as DEC writes
it.

The indirect character is `*' for Unix compatibility, not `@' as DEC writes it.

The displacement sizing character is ``' (an accent grave) for Unix
compatibility, not `^' as DEC writes it.  The letter preceding ``' may have
either case.  `G' is not understood, but all other letters (b i l s w) are
understood.

Register names understood are r0 r1 r2 ... r15 ap fp sp pc.  Upper and lower
case letters are equivalent.

For instance

tstb *w`$4(r5)

Any expression is permitted in an operand.  Operands are comma separated.


ΓòÉΓòÉΓòÉ 11.7. Not Supported on VAX ΓòÉΓòÉΓòÉ

Vax bit fields can not be assembled with as.  Someone can add the required code
if they really need it.


ΓòÉΓòÉΓòÉ 12. AMD 29K Dependent Features ΓòÉΓòÉΓòÉ

 AMD29K Options                          Options
 AMD29K Syntax                           Syntax
 AMD29K Floating Point                   Floating Point
 AMD29K Directives                       AMD 29K Machine Directives
 AMD29K Opcodes                          Opcodes


ΓòÉΓòÉΓòÉ 12.1. Options ΓòÉΓòÉΓòÉ

as has no additional command-line options for the AMD 29K family.


ΓòÉΓòÉΓòÉ 12.2. Syntax ΓòÉΓòÉΓòÉ

 AMD29K-Chars                            Special Characters
 AMD29K-Regs                             Register Names


ΓòÉΓòÉΓòÉ 12.2.1. Special Characters ΓòÉΓòÉΓòÉ

`;' is the line comment character.

`@' can be used instead of a newline to separate statements.

The character `?' is permitted in identifiers (but may not begin an
identifier).


ΓòÉΓòÉΓòÉ 12.2.2. Register Names ΓòÉΓòÉΓòÉ

General-purpose registers are represented by predefined symbols of the form
`GRnnn' (for global registers) or `LRnnn' (for local registers), where nnn
represents a number between 0 and 127, written with no leading zeros.  The
leading letters may be in either upper or lower case; for example, `gr13' and
`LR7' are both valid register names.

You may also refer to general-purpose registers by specifying the register
number as the result of an expression (prefixed with `%%' to flag the
expression as a register number):

%%expression

---where expression must be an absolute expression evaluating to a number
between 0 and 255.  The range [0, 127] refers to global registers, and the
range [128, 255] to local registers.

In addition, as understands the following protected special-purpose register
names for the AMD 29K family:

  vab    chd    pc0
  ops    chc    pc1
  cps    rbp    pc2
  cfg    tmc    mmu
  cha    tmr    lru

These unprotected special-purpose register names are also recognized:

  ipc    alu    fpe
  ipa    bp     inte
  ipb    fc     fps
  q      cr     exop


ΓòÉΓòÉΓòÉ 12.3. Floating Point ΓòÉΓòÉΓòÉ

The AMD 29K family uses ieee floating-point numbers.


ΓòÉΓòÉΓòÉ 12.4. AMD 29K Machine Directives ΓòÉΓòÉΓòÉ

 .block size , fill
           This directive emits size bytes, each of value fill.  Both size and
           fill are absolute expressions.  If the comma and fill are omitted,
           fill is assumed to be zero.

           In other versions of the gnu assembler, this directive is called
           `.space'.

 .cputype
           This directive is ignored; it is accepted for compatibility with
           other AMD 29K assemblers.

 .file
           This directive is ignored; it is accepted for compatibility with
           other AMD 29K assemblers.

           Warning: in other versions of the gnu assembler, .file is used for
           the directive called .app-file in the AMD 29K support.

 .line
           This directive is ignored; it is accepted for compatibility with
           other AMD 29K assemblers.

 .sect
           This directive is ignored; it is accepted for compatibility with
           other AMD 29K assemblers.

 .use section name
           Establishes the section and subsection for the following code;
           section name may be one of .text, .data, .data1, or .lit.  With one
           of the first three section name options, `.use' is equivalent to the
           machine directive section name; the remaining case, `.use .lit', is
           the same as `.data 200'.


ΓòÉΓòÉΓòÉ 12.5. Opcodes ΓòÉΓòÉΓòÉ

as implements all the standard AMD 29K opcodes.  No additional
pseudo-instructions are needed on this family.

For information on the 29K machine instruction set, see Am29000 User's Manual,
Advanced Micro Devices, Inc.

 H8/300-Dependent                        Hitachi H8/300 Dependent Features


 H8/500-Dependent                        Hitachi H8/500 Dependent Features
 SH-Dependent                            Hitachi SH Dependent Features


ΓòÉΓòÉΓòÉ 13. H8/300 Dependent Features ΓòÉΓòÉΓòÉ

 H8/300 Options                          Options
 H8/300 Syntax                           Syntax
 H8/300 Floating Point                   Floating Point
 H8/300 Directives                       H8/300 Machine Directives
 H8/300 Opcodes                          Opcodes


ΓòÉΓòÉΓòÉ 13.1. Options ΓòÉΓòÉΓòÉ

as has no additional command-line options for the Hitachi H8/300 family.


ΓòÉΓòÉΓòÉ 13.2. Syntax ΓòÉΓòÉΓòÉ

 H8/300-Chars                            Special Characters
 H8/300-Regs                             Register Names
 H8/300-Addressing                       Addressing Modes


ΓòÉΓòÉΓòÉ 13.2.1. Special Characters ΓòÉΓòÉΓòÉ

`;' is the line comment character.

`$' can be used instead of a newline to separate statements. Therefore you may
not use `$' in symbol names on the H8/300.


ΓòÉΓòÉΓòÉ 13.2.2. Register Names ΓòÉΓòÉΓòÉ

You can use predefined symbols of the form `rnh' and `rnl' to refer to the
H8/300 registers as sixteen 8-bit general-purpose registers.  n is a digit from
`0' to `7'); for instance, both `r0h' and `r7l' are valid register names.

You can also use the eight predefined symbols `rn' to refer to the H8/300
registers as 16-bit registers (you must use this form for addressing).

On the H8/300H, you can also use the eight predefined symbols `ern' (`er0' ...
`er7') to refer to the 32-bit general purpose registers.

The two control registers are called pc (program counter; a 16-bit register,
except on the H8/300H where it is 24 bits) and ccr (condition code register; an
8-bit register).  r7 is used as the stack pointer, and can also be called sp.


ΓòÉΓòÉΓòÉ 13.2.3. Addressing Modes ΓòÉΓòÉΓòÉ

as understands the following addressing modes for the H8/300:

 rn
           Register direct

 @rn
           Register indirect

 @(d, rn)
 @(d:16, rn)
 @(d:24, rn)
           Register indirect: 16-bit or 24-bit displacement d from register n.
           (24-bit displacements are only meaningful on the H8/300H.)

 @rn+
           Register indirect with post-increment

 @-rn
           Register indirect with pre-decrement

 @aa
 @aa:8
 @aa:16
 @aa:24
           Absolute address aa.  (The address size `:24' only makes sense on
           the H8/300H.)

 #xx
 #xx:8
 #xx:16
 #xx:32
           Immediate data xx.  You may specify the `:8', `:16', or `:32' for
           clarity, if you wish; but as neither requires this nor uses it---the
           data size required is taken from context.

 @@aa
 @@aa:8
           Memory indirect.  You may specify the `:8' for clarity, if you wish;
           but as neither requires this nor uses it.


ΓòÉΓòÉΓòÉ 13.3. Floating Point ΓòÉΓòÉΓòÉ

The H8/300 family has no hardware floating point, but the .float directive
generates ieee floating-point numbers for compatibility with other development
tools.


ΓòÉΓòÉΓòÉ 13.4. H8/300 Machine Directives ΓòÉΓòÉΓòÉ

as has only one machine-dependent directive for the H8/300:

 .h300h
           Recognize and emit additional instructions for the H8/300H variant,
           and also make .int emit 32-bit numbers rather than the usual
           (16-bit) for the H8/300 family.

 On the H8/300 family (including the H8/300H) `.word' directives generate
 16-bit numbers.


ΓòÉΓòÉΓòÉ 13.5. Opcodes ΓòÉΓòÉΓòÉ

For detailed information on the H8/300 machine instruction set, see H8/300
Series Programming Manual (Hitachi ADE--602--025).  For information specific to
the H8/300H, see H8/300H Series Programming Manual (Hitachi).

as implements all the standard H8/300 opcodes.  No additional
pseudo-instructions are needed on this family.

The following table summarizes the H8/300 opcodes, and their arguments. Entries
marked `*' are opcodes used only on the H8/300H.

         Legend:
            Rs   source register
            Rd   destination register
            abs  absolute address
            imm  immediate data
         disp:N  N-bit displacement from a register
        pcrel:N  N-bit displacement relative to program counter

   add.b #imm,rd              *  andc #imm,ccr
   add.b rs,rd                   band #imm,rd
   add.w rs,rd                   band #imm,@rd
*  add.w #imm,rd                 band #imm,@abs:8
*  add.l rs,rd                   bra  pcrel:8
*  add.l #imm,rd              *  bra  pcrel:16
   adds #imm,rd                  bt   pcrel:8
   addx #imm,rd               *  bt   pcrel:16
   addx rs,rd                    brn  pcrel:8
   and.b #imm,rd              *  brn  pcrel:16
   and.b rs,rd                   bf   pcrel:8
*  and.w rs,rd                *  bf   pcrel:16
*  and.w #imm,rd                 bhi  pcrel:8
*  and.l #imm,rd              *  bhi  pcrel:16
*  and.l rs,rd                   bls  pcrel:8

*  bls  pcrel:16                 bld  #imm,rd
   bcc  pcrel:8                  bld  #imm,@rd
*  bcc  pcrel:16                 bld  #imm,@abs:8
   bhs  pcrel:8                  bnot #imm,rd
*  bhs  pcrel:16                 bnot #imm,@rd
   bcs  pcrel:8                  bnot #imm,@abs:8
*  bcs  pcrel:16                 bnot rs,rd
   blo  pcrel:8                  bnot rs,@rd
*  blo  pcrel:16                 bnot rs,@abs:8
   bne  pcrel:8                  bor  #imm,rd
*  bne  pcrel:16                 bor  #imm,@rd
   beq  pcrel:8                  bor  #imm,@abs:8
*  beq  pcrel:16                 bset #imm,rd
   bvc  pcrel:8                  bset #imm,@rd
*  bvc  pcrel:16                 bset #imm,@abs:8
   bvs  pcrel:8                  bset rs,rd
*  bvs  pcrel:16                 bset rs,@rd
   bpl  pcrel:8                  bset rs,@abs:8
*  bpl  pcrel:16                 bsr  pcrel:8
   bmi  pcrel:8                  bsr  pcrel:16
*  bmi  pcrel:16                 bst  #imm,rd
   bge  pcrel:8                  bst  #imm,@rd
*  bge  pcrel:16                 bst  #imm,@abs:8
   blt  pcrel:8                  btst #imm,rd
*  blt  pcrel:16                 btst #imm,@rd
   bgt  pcrel:8                  btst #imm,@abs:8
*  bgt  pcrel:16                 btst rs,rd
   ble  pcrel:8                  btst rs,@rd
*  ble  pcrel:16                 btst rs,@abs:8
   bclr #imm,rd                  bxor #imm,rd
   bclr #imm,@rd                 bxor #imm,@rd
   bclr #imm,@abs:8              bxor #imm,@abs:8
   bclr rs,rd                    cmp.b #imm,rd
   bclr rs,@rd                   cmp.b rs,rd
   bclr rs,@abs:8                cmp.w rs,rd
   biand #imm,rd                 cmp.w rs,rd
   biand #imm,@rd             *  cmp.w #imm,rd
   biand #imm,@abs:8          *  cmp.l #imm,rd
   bild #imm,rd               *  cmp.l rs,rd
   bild #imm,@rd                 daa  rs
   bild #imm,@abs:8              das  rs
   bior #imm,rd                  dec.b rs
   bior #imm,@rd              *  dec.w #imm,rd
   bior #imm,@abs:8           *  dec.l #imm,rd
   bist #imm,rd                  divxu.b rs,rd
   bist #imm,@rd              *  divxu.w rs,rd
   bist #imm,@abs:8           *  divxs.b rs,rd
   bixor #imm,rd              *  divxs.w rs,rd
   bixor #imm,@rd                eepmov
   bixor #imm,@abs:8          *  eepmovw

*  exts.w rd                     mov.w rs,@abs:16
*  exts.l rd                  *  mov.l #imm,rd
*  extu.w rd                  *  mov.l rs,rd
*  extu.l rd                  *  mov.l @rs,rd
   inc  rs                    *  mov.l @(disp:16,rs),rd
*  inc.w #imm,rd              *  mov.l @(disp:24,rs),rd
*  inc.l #imm,rd              *  mov.l @rs+,rd
   jmp  @rs                   *  mov.l @abs:16,rd
   jmp  abs                   *  mov.l @abs:24,rd
   jmp  @@abs:8               *  mov.l rs,@rd
   jsr  @rs                   *  mov.l rs,@(disp:16,rd)
   jsr  abs                   *  mov.l rs,@(disp:24,rd)
   jsr  @@abs:8               *  mov.l rs,@-rd
   ldc  #imm,ccr              *  mov.l rs,@abs:16
   ldc  rs,ccr                *  mov.l rs,@abs:24
*  ldc  @abs:16,ccr              movfpe @abs:16,rd
*  ldc  @abs:24,ccr              movtpe rs,@abs:16
*  ldc  @(disp:16,rs),ccr        mulxu.b rs,rd
*  ldc  @(disp:24,rs),ccr     *  mulxu.w rs,rd
*  ldc  @rs+,ccr              *  mulxs.b rs,rd
*  ldc  @rs,ccr               *  mulxs.w rs,rd
*  mov.b @(disp:24,rs),rd        neg.b rs
*  mov.b rs,@(disp:24,rd)     *  neg.w rs
   mov.b @abs:16,rd           *  neg.l rs
   mov.b rs,rd                   nop
   mov.b @abs:8,rd               not.b rs
   mov.b rs,@abs:8            *  not.w rs
   mov.b rs,rd                *  not.l rs
   mov.b #imm,rd                 or.b #imm,rd
   mov.b @rs,rd                  or.b rs,rd
   mov.b @(disp:16,rs),rd     *  or.w #imm,rd
   mov.b @rs+,rd              *  or.w rs,rd
   mov.b @abs:8,rd            *  or.l #imm,rd
   mov.b rs,@rd               *  or.l rs,rd
   mov.b rs,@(disp:16,rd)        orc  #imm,ccr
   mov.b rs,@-rd                 pop.w rs
   mov.b rs,@abs:8            *  pop.l rs
   mov.w rs,@rd                  push.w rs
*  mov.w @(disp:24,rs),rd     *  push.l rs
*  mov.w rs,@(disp:24,rd)        rotl.b rs
*  mov.w @abs:24,rd           *  rotl.w rs
*  mov.w rs,@abs:24           *  rotl.l rs
   mov.w rs,rd                   rotr.b rs
   mov.w #imm,rd              *  rotr.w rs
   mov.w @rs,rd               *  rotr.l rs
   mov.w @(disp:16,rs),rd        rotxl.b rs
   mov.w @rs+,rd              *  rotxl.w rs
   mov.w @abs:16,rd           *  rotxl.l rs
   mov.w rs,@(disp:16,rd)        rotxr.b rs
   mov.w rs,@-rd              *  rotxr.w rs

*  rotxr.l rs                 *  stc  ccr,@(disp:24,rd)
   bpt                        *  stc  ccr,@-rd
   rte                        *  stc  ccr,@abs:16
   rts                        *  stc  ccr,@abs:24
   shal.b rs                     sub.b rs,rd
*  shal.w rs                     sub.w rs,rd
*  shal.l rs                  *  sub.w #imm,rd
   shar.b rs                  *  sub.l rs,rd
*  shar.w rs                  *  sub.l #imm,rd
*  shar.l rs                     subs #imm,rd
   shll.b rs                     subx #imm,rd
*  shll.w rs                     subx rs,rd
*  shll.l rs                  *  trapa #imm
   shlr.b rs                     xor  #imm,rd
*  shlr.w rs                     xor  rs,rd
*  shlr.l rs                  *  xor.w #imm,rd
   sleep                      *  xor.w rs,rd
   stc  ccr,rd                *  xor.l #imm,rd
*  stc  ccr,@rs               *  xor.l rs,rd
*  stc  ccr,@(disp:16,rd)        xorc #imm,ccr

Four H8/300 instructions (add, cmp, mov, sub) are defined with variants using
the suffixes `.b', `.w', and `.l' to specify the size of a memory operand. as
supports these suffixes, but does not require them; since one of the operands
is always a register, as can deduce the correct size.

For example, since r0 refers to a 16-bit register,

mov    r0,@foo
is equivalent to
mov.w  r0,@foo

If you use the size suffixes, as issues a warning when the suffix and the
register size do not match.


ΓòÉΓòÉΓòÉ 14. H8/500 Dependent Features ΓòÉΓòÉΓòÉ

 H8/500 Options                          Options
 H8/500 Syntax                           Syntax
 H8/500 Floating Point                   Floating Point
 H8/500 Directives                       H8/500 Machine Directives
 H8/500 Opcodes                          Opcodes


ΓòÉΓòÉΓòÉ 14.1. Options ΓòÉΓòÉΓòÉ

as has no additional command-line options for the Hitachi H8/500 family.


ΓòÉΓòÉΓòÉ 14.2. Syntax ΓòÉΓòÉΓòÉ

 H8/500-Chars                            Special Characters
 H8/500-Regs                             Register Names
 H8/500-Addressing                       Addressing Modes


ΓòÉΓòÉΓòÉ 14.2.1. Special Characters ΓòÉΓòÉΓòÉ

`!' is the line comment character.

`;' can be used instead of a newline to separate statements.

Since `$' has no special meaning, you may use it in symbol names.


ΓòÉΓòÉΓòÉ 14.2.2. Register Names ΓòÉΓòÉΓòÉ

You can use the predefined symbols `r0', `r1', `r2', `r3', `r4', `r5', `r6',
and `r7' to refer to the H8/500 registers.

The H8/500 also has these control registers:

 cp
           code pointer

 dp
           data pointer

 bp
           base pointer

 tp
           stack top pointer

 ep
           extra pointer

 sr
           status register

 ccr
           condition code register

 All registers are 16 bits long.  To represent 32 bit numbers, use two adjacent
 registers; for distant memory addresses, use one of the segment pointers (cp
 for the program counter; dp for r0--r3; ep for r4 and r5; and tp for r6 and
 r7.


ΓòÉΓòÉΓòÉ 14.2.3. Addressing Modes ΓòÉΓòÉΓòÉ

as understands the following addressing modes for the H8/500:

 Rn
           Register direct

 @Rn
           Register indirect

 @(d:8, Rn)
           Register indirect with 8 bit signed displacement

 @(d:16, Rn)
           Register indirect with 16 bit signed displacement

 @-Rn
           Register indirect with pre-decrement

 @Rn+
           Register indirect with post-increment

 @aa:8
           8 bit absolute address

 @aa:16
           16 bit absolute address

 #xx:8
           8 bit immediate

 #xx:16
           16 bit immediate


ΓòÉΓòÉΓòÉ 14.3. Floating Point ΓòÉΓòÉΓòÉ

The H8/500 family uses ieee floating-point numbers.


ΓòÉΓòÉΓòÉ 14.4. H8/500 Machine Directives ΓòÉΓòÉΓòÉ

as has no machine-dependent directives for the H8/500. However, on this
platform the `.int' and `.word' directives generate 16-bit numbers.


ΓòÉΓòÉΓòÉ 14.5. Opcodes ΓòÉΓòÉΓòÉ

For detailed information on the H8/500 machine instruction set, see H8/500
Series Programming Manual (Hitachi M21T001).

as implements all the standard H8/500 opcodes.  No additional
pseudo-instructions are needed on this family.

The following table summarizes H8/500 opcodes and their operands:

Legend:
abs8      8-bit absolute address
abs16     16-bit absolute address
abs24     24-bit absolute address
crb       ccr, br, ep, dp, tp, dp
disp8     8-bit displacement
ea        rn, @rn, @(d:8, rn), @(d:16, rn),
          @-rn, @rn+, @aa:8, @aa:16,
          #xx:8, #xx:16
ea_mem    @rn, @(d:8, rn), @(d:16, rn),
          @-rn, @rn+, @aa:8, @aa:16
ea_noimm  rn, @rn, @(d:8, rn), @(d:16, rn),
          @-rn, @rn+, @aa:8, @aa:16
fp        r6
imm4      4-bit immediate data
imm8      8-bit immediate data
imm16     16-bit immediate data
pcrel8    8-bit offset from program counter
pcrel16   16-bit offset from program counter
qim       -2, -1, 1, 2
rd        any register
rs        a register distinct from rd
rlist     comma-separated list of registers in parentheses;
          register ranges rd-rs are allowed
sp        stack pointer (r7)
sr        status register
sz        size; `.b' or `.w'.  If omitted, default `.w'

ldc[.b] ea,crb                 bcc[.w] pcrel16
ldc[.w] ea,sr                  bcc[.b] pcrel8
add[:q] sz qim,ea_noimm        bhs[.w] pcrel16
add[:g] sz ea,rd               bhs[.b] pcrel8
adds sz ea,rd                  bcs[.w] pcrel16
addx sz ea,rd                  bcs[.b] pcrel8
and sz ea,rd                   blo[.w] pcrel16
andc[.b] imm8,crb              blo[.b] pcrel8
andc[.w] imm16,sr              bne[.w] pcrel16
bpt                            bne[.b] pcrel8
bra[.w] pcrel16                beq[.w] pcrel16
bra[.b] pcrel8                 beq[.b] pcrel8
bt[.w] pcrel16                 bvc[.w] pcrel16
bt[.b] pcrel8                  bvc[.b] pcrel8
brn[.w] pcrel16                bvs[.w] pcrel16
brn[.b] pcrel8                 bvs[.b] pcrel8
bf[.w] pcrel16                 bpl[.w] pcrel16
bf[.b] pcrel8                  bpl[.b] pcrel8
bhi[.w] pcrel16                bmi[.w] pcrel16
bhi[.b] pcrel8                 bmi[.b] pcrel8
bls[.w] pcrel16                bge[.w] pcrel16
bls[.b] pcrel8                 bge[.b] pcrel8

blt[.w] pcrel16                mov[:g][.b] imm8,ea_mem
blt[.b] pcrel8                 mov[:g][.w] imm16,ea_mem
bgt[.w] pcrel16                movfpe[.b] ea,rd
bgt[.b] pcrel8                 movtpe[.b] rs,ea_noimm
ble[.w] pcrel16                mulxu sz ea,rd
ble[.b] pcrel8                 neg sz ea
bclr sz imm4,ea_noimm          nop
bclr sz rs,ea_noimm            not sz ea
bnot sz imm4,ea_noimm          or sz ea,rd
bnot sz rs,ea_noimm            orc[.b] imm8,crb
bset sz imm4,ea_noimm          orc[.w] imm16,sr
bset sz rs,ea_noimm            pjmp abs24
bsr[.b] pcrel8                 pjmp @rd
bsr[.w] pcrel16                pjsr abs24
btst sz imm4,ea_noimm          pjsr @rd
btst sz rs,ea_noimm            prtd imm8
clr sz ea                      prtd imm16
cmp[:e][.b] imm8,rd            prts
cmp[:i][.w] imm16,rd           rotl sz ea
cmp[:g].b imm8,ea_noimm        rotr sz ea
cmp[:g][.w] imm16,ea_noimm     rotxl sz ea
Cmp[:g] sz ea,rd               rotxr sz ea
dadd rs,rd                     rtd imm8
divxu sz ea,rd                 rtd imm16
dsub rs,rd                     rts
exts[.b] rd                    scb/f rs,pcrel8
extu[.b] rd                    scb/ne rs,pcrel8
jmp @rd                        scb/eq rs,pcrel8
jmp @(imm8,rd)                 shal sz ea
jmp @(imm16,rd)                shar sz ea
jmp abs16                      shll sz ea
jsr @rd                        shlr sz ea
jsr @(imm8,rd)                 sleep
jsr @(imm16,rd)                stc[.b] crb,ea_noimm
jsr abs16                      stc[.w] sr,ea_noimm
ldm @sp+,(rlist)               stm (rlist),@-sp
link fp,imm8                   sub sz ea,rd
link fp,imm16                  subs sz ea,rd
mov[:e][.b] imm8,rd            subx sz ea,rd
mov[:i][.w] imm16,rd           swap[.b] rd
mov[:l][.w] abs8,rd            tas[.b] ea
mov[:l].b abs8,rd              trapa imm4
mov[:s][.w] rs,abs8            trap/vs
mov[:s].b rs,abs8              tst sz ea
mov[:f][.w] @(disp8,fp),rd     unlk fp
mov[:f][.w] rs,@(disp8,fp)     xch[.w] rs,rd
mov[:f].b @(disp8,fp),rd       xor sz ea,rd
mov[:f].b rs,@(disp8,fp)       xorc.b imm8,crb
mov[:g] sz rs,ea_mem           xorc.w imm16,sr
mov[:g] sz ea,rd


ΓòÉΓòÉΓòÉ 15. HPPA Dependent Features ΓòÉΓòÉΓòÉ

 HPPA Notes                              Notes
 HPPA Options                            Options
 HPPA Syntax                             Syntax
 HPPA Floating Point                     Floating Point
 HPPA Directives                         HPPA Machine Directives
 HPPA Opcodes                            Opcodes


ΓòÉΓòÉΓòÉ 15.1. Notes ΓòÉΓòÉΓòÉ

As a back end for gnu cc as has been throughly tested and should work extremely
well.  We have tested it only minimally on hand written assembly code and no
one has tested it much on the assembly output from the HP compilers.

The format of the debugging sections has changed since the original as port
(version 1.3X) was released; therefore, you must rebuild all HPPA objects and
libraries with the new assembler so that you can debug the final executable.

The HPPA as port generates a small subset of the relocations available in the
SOM and ELF object file formats.  Additional relocation support will be added
as it becomes necessary.


ΓòÉΓòÉΓòÉ 15.2. Options ΓòÉΓòÉΓòÉ

as has no machine-dependent command-line options for the HPPA.


ΓòÉΓòÉΓòÉ 15.3. Syntax ΓòÉΓòÉΓòÉ

The assembler syntax closely follows the HPPA instruction set reference manual;
assembler directives and general syntax closely follow the HPPA assembly
language reference manual, with a few noteworthy differences.

First, a colon may immediately follow a label definition.  This is simply for
compatibility with how most assembly language programmers write code.

Some obscure expression parsing problems may affect hand written code which
uses the spop instructions, or code which makes significant use of the ! line
separator.

as is much less forgiving about missing arguments and other similar oversights
than the HP assembler.  as notifies you of missing arguments as syntax errors;
this is regarded as a feature, not a bug.

Finally, as allows you to use an external symbol without explicitly importing
the symbol.  Warning: in the future this will be an error for HPPA targets.

Special characters for HPPA targets include:

`;' is the line comment character.

`!' can be used instead of a newline to separate statements.

Since `$' has no special meaning, you may use it in symbol names.


ΓòÉΓòÉΓòÉ 15.4. Floating Point ΓòÉΓòÉΓòÉ

The HPPA family uses ieee floating-point numbers.


ΓòÉΓòÉΓòÉ 15.5. HPPA Assembler Directives ΓòÉΓòÉΓòÉ

as for the HPPA supports many additional directives for compatibility with the
native assembler.  This section describes them only briefly.  For detailed
information on HPPA-specific assembler directives, see HP9000 Series 800
Assembly Language Reference Manual (HP 92432-90001).

as does not support the following assembler directives described in the HP
manual:

.endm           .liston
.enter          .locct
.leave          .macro
.listoff

Beyond those implemented for compatibility, as supports one additional
assembler directive for the HPPA: .param.  It conveys register argument
locations for static functions.  Its syntax closely follows the .export
directive.

These are the additional directives in as for the HPPA:

 .block n
 .blockz n
           Reserve n bytes of storage, and initialize them to zero.

 .call
           Mark the beginning of a procedure call.  Only the special case with
           no arguments is allowed.

 .callinfo [ param=value, ... ]  [ flag, ... ]
           Specify a number of parameters and flags that define the environment
           for a procedure.

           param may be any of `frame' (frame size), `entry_gr' (end of general
           register range), `entry_fr' (end of float register range),
           `entry_sr' (end of space register range).

           The values for flag are `calls' or `caller' (proc has subroutines),
           `no_calls' (proc does not call subroutines), `save_rp' (preserve
           return pointer), `save_sp' (proc preserves stack pointer),
           `no_unwind' (do not unwind this proc), `hpux_int' (proc is interrupt
           routine).

 .code
           Assemble into the standard section called `$TEXT$', subsection
           `$CODE$'.

 .copyright "string"
           In the SOM object format, insert string into the object code, marked
           as a copyright string.

 .copyright "string"
           In the ELF object format, insert string into the object code, marked
           as a version string.

 .enter
           Not yet supported; the assembler rejects programs containing this
           directive.

 .entry
           Mark the beginning of a procedure.

 .exit
           Mark the end of a procedure.

 .export name [ ,typ ]  [ ,param=r ]
           Make a procedure name available to callers.  typ, if present, must
           be one of `absolute', `code' (ELF only, not SOM), `data', `entry',
           `data', `entry', `millicode', `plabel', `pri_prog', or `sec_prog'.

           param, if present, provides either relocation information for the
           procedure arguments and result, or a privilege level.  param may be
           `argwn' (where n ranges from 0 to 3, and indicates one of four
           one-word arguments); `rtnval' (the procedure's result); or
           `priv_lev' (privilege level).  For arguments or the result, r
           specifies how to relocate, and must be one of `no' (not
           relocatable), `gr' (argument is in general register), `fr' (in
           floating point register), or `fu' (upper half of float register).
           For `priv_lev', r is an integer.

 .half n
           Define a two-byte integer constant n; synonym for the portable as
           directive .short.

 .import name [ ,typ ]
           Converse of .export; make a procedure available to call.  The
           arguments use the same conventions as the first two arguments for
           .export.

 .label name
           Define name as a label for the current assembly location.

 .leave
           Not yet supported; the assembler rejects programs containing this
           directive.

 .origin lc
           Advance location counter to lc. Synonym for the  portable directive
           .org.

 .param name [ ,typ ]  [ ,param=r ]
           Similar to .export, but used for static procedures.

 .proc
           Use preceding the first statement of a procedure.

 .procend
           Use following the last statement of a procedure.

 label .reg expr
           Synonym for .equ; define label with the absolute expression expr as
           its value.

 .space secname [ ,params ]
           Switch to section secname, creating a new section by that name if
           necessary.  You may only use params when creating a new section, not
           when switching to an existing one.  secname may identify a section
           by number rather than by name.

           If specified, the list params declares attributes of the section,
           identified by keywords.  The keywords recognized are `spnum=exp'
           (identify this section by the number exp, an absolute expression),
           `sort=exp' (order sections according to this sort key when linking;
           exp is an absolute expression), `unloadable' (section contains no
           loadable data), `notdefined' (this section defined elsewhere), and
           `private' (data in this section not available to other programs).

 .spnum secnam
           Allocate four bytes of storage, and initialize them with the section
           number of the section named secnam.  (You can define the section
           number with the HPPA .space directive.)

 .string "str"
           Copy the characters in the string str to the object file. See
           Strings, for information on escape sequences you can use in as
           strings.

           Warning! The HPPA version of .string differs from the usual as
           definition: it does not write a zero byte after copying str.

 .stringz "str"
           Like .string, but appends a zero byte after copying str to object
           file.

 .subspa name [ ,params ]
           Similar to .space, but selects a subsection name within the current
           section.  You may only specify params when you create a subsection
           (in the first instance of .subspa for this name).

           If specified, the list params declares attributes of the subsection,
           identified by keywords.  The keywords recognized are `quad=expr'
           (``quadrant'' for this subsection), `align=expr' (alignment for
           beginning of this subsection; a power of two), `access=expr' (value
           for ``access rights'' field), `sort=expr' (sorting order for this
           subspace in link), `code_only' (subsection contains only code),
           `unloadable' (subsection cannot be loaded into memory), `common'
           (subsection is common block), `dup_comm' (initialized data may have
           duplicate names), or `zero' (subsection is all zeros, do not write
           in object file).

 .version "str"
           Write str as version identifier in object code.


ΓòÉΓòÉΓòÉ 15.6. Opcodes ΓòÉΓòÉΓòÉ

For detailed information on the HPPA machine instruction set, see PA-RISC
Architecture and Instruction Set Reference Manual (HP 09740-90039).


ΓòÉΓòÉΓòÉ 16. Hitachi SH Dependent Features ΓòÉΓòÉΓòÉ

 SH Options                              Options
 SH Syntax                               Syntax
 SH Floating Point                       Floating Point
 SH Directives                           SH Machine Directives
 SH Opcodes                              Opcodes


ΓòÉΓòÉΓòÉ 16.1. Options ΓòÉΓòÉΓòÉ

as has no additional command-line options for the Hitachi SH family.


ΓòÉΓòÉΓòÉ 16.2. Syntax ΓòÉΓòÉΓòÉ

 SH-Chars                                Special Characters
 SH-Regs                                 Register Names
 SH-Addressing                           Addressing Modes


ΓòÉΓòÉΓòÉ 16.2.1. Special Characters ΓòÉΓòÉΓòÉ

`!' is the line comment character.

You can use `;' instead of a newline to separate statements.

Since `$' has no special meaning, you may use it in symbol names.


ΓòÉΓòÉΓòÉ 16.2.2. Register Names ΓòÉΓòÉΓòÉ

You can use the predefined symbols `r0', `r1', `r2', `r3', `r4', `r5', `r6',
`r7', `r8', `r9', `r10', `r11', `r12', `r13', `r14', and `r15' to refer to the
SH registers.

The SH also has these control registers:

 pr
           procedure register (holds return address)

 pc
           program counter

 mach
 macl
           high and low multiply accumulator registers

 sr
           status register

 gbr
           global base register

 vbr
           vector base register (for interrupt vectors)


ΓòÉΓòÉΓòÉ 16.2.3. Addressing Modes ΓòÉΓòÉΓòÉ

as understands the following addressing modes for the SH. Rn in the following
refers to any of the numbered registers, but not the control registers.

 Rn
           Register direct

 @Rn
           Register indirect

 @-Rn
           Register indirect with pre-decrement

 @Rn+
           Register indirect with post-increment

 @(disp, Rn)
           Register indirect with displacement

 @(R0, Rn)
           Register indexed

 @(disp, GBR)
           GBR offset

 @(R0, GBR)
           GBR indexed

 addr
 @(disp, PC)
           PC relative address (for branch or for addressing memory).  The as
           implementation allows you to use the simpler form addr anywhere a PC
           relative address is called for; the alternate form is supported for
           compatibility with other assemblers.

 #imm
           Immediate data


ΓòÉΓòÉΓòÉ 16.3. Floating Point ΓòÉΓòÉΓòÉ

The SH family uses ieee floating-point numbers.


ΓòÉΓòÉΓòÉ 16.4. SH Machine Directives ΓòÉΓòÉΓòÉ

as has no machine-dependent directives for the SH.


ΓòÉΓòÉΓòÉ 16.5. Opcodes ΓòÉΓòÉΓòÉ

For detailed information on the SH machine instruction set, see
SH-Microcomputer User's Manual (Hitachi Micro Systems, Inc.).

as implements all the standard SH opcodes.  No additional pseudo-instructions
are needed on this family.  Note, however, that because as supports a simpler
form of PC-relative addressing, you may simply write (for example)

mov.l  bar,r0

where other assemblers might require an explicit displacement to bar from the
program counter:

mov.l  @(disp, PC)

Here is a summary of SH opcodes:

Legend:
Rn        a numbered register
Rm        another numbered register
#imm      immediate data
disp      displacement
disp8     8-bit displacement
disp12    12-bit displacement

add #imm,Rn                    lds.l @Rn+,PR
add Rm,Rn                      mac.w @Rm+,@Rn+
addc Rm,Rn                     mov #imm,Rn
addv Rm,Rn                     mov Rm,Rn
and #imm,R0                    mov.b Rm,@(R0,Rn)
and Rm,Rn                      mov.b Rm,@-Rn
and.b #imm,@(R0,GBR)           mov.b Rm,@Rn
bf disp8                       mov.b @(disp,Rm),R0
bra disp12                     mov.b @(disp,GBR),R0
bsr disp12                     mov.b @(R0,Rm),Rn
bt disp8                       mov.b @Rm+,Rn
clrmac                         mov.b @Rm,Rn
clrt                           mov.b R0,@(disp,Rm)
cmp/eq #imm,R0                 mov.b R0,@(disp,GBR)
cmp/eq Rm,Rn                   mov.l Rm,@(disp,Rn)
cmp/ge Rm,Rn                   mov.l Rm,@(R0,Rn)
cmp/gt Rm,Rn                   mov.l Rm,@-Rn
cmp/hi Rm,Rn                   mov.l Rm,@Rn
cmp/hs Rm,Rn                   mov.l @(disp,Rn),Rm
cmp/pl Rn                      mov.l @(disp,GBR),R0
cmp/pz Rn                      mov.l @(disp,PC),Rn
cmp/str Rm,Rn                  mov.l @(R0,Rm),Rn
div0s Rm,Rn                    mov.l @Rm+,Rn
div0u                          mov.l @Rm,Rn
div1 Rm,Rn                     mov.l R0,@(disp,GBR)
exts.b Rm,Rn                   mov.w Rm,@(R0,Rn)
exts.w Rm,Rn                   mov.w Rm,@-Rn
extu.b Rm,Rn                   mov.w Rm,@Rn
extu.w Rm,Rn                   mov.w @(disp,Rm),R0
jmp @Rn                        mov.w @(disp,GBR),R0
jsr @Rn                        mov.w @(disp,PC),Rn
ldc Rn,GBR                     mov.w @(R0,Rm),Rn
ldc Rn,SR                      mov.w @Rm+,Rn
ldc Rn,VBR                     mov.w @Rm,Rn
ldc.l @Rn+,GBR                 mov.w R0,@(disp,Rm)
ldc.l @Rn+,SR                  mov.w R0,@(disp,GBR)
ldc.l @Rn+,VBR                 mova @(disp,PC),R0
lds Rn,MACH                    movt Rn
lds Rn,MACL                    muls Rm,Rn
lds Rn,PR                      mulu Rm,Rn
lds.l @Rn+,MACH                neg Rm,Rn
lds.l @Rn+,MACL                negc Rm,Rn

nop                            stc VBR,Rn
not Rm,Rn                      stc.l GBR,@-Rn
or #imm,R0                     stc.l SR,@-Rn
or Rm,Rn                       stc.l VBR,@-Rn
or.b #imm,@(R0,GBR)            sts MACH,Rn
rotcl Rn                       sts MACL,Rn
rotcr Rn                       sts PR,Rn
rotl Rn                        sts.l MACH,@-Rn
rotr Rn                        sts.l MACL,@-Rn
rte                            sts.l PR,@-Rn
rts                            sub Rm,Rn
sett                           subc Rm,Rn
shal Rn                        subv Rm,Rn
shar Rn                        swap.b Rm,Rn
shll Rn                        swap.w Rm,Rn
shll16 Rn                      tas.b @Rn
shll2 Rn                       trapa #imm
shll8 Rn                       tst #imm,R0
shlr Rn                        tst Rm,Rn
shlr16 Rn                      tst.b #imm,@(R0,GBR)
shlr2 Rn                       xor #imm,R0
shlr8 Rn                       xor Rm,Rn
sleep                          xor.b #imm,@(R0,GBR)
stc GBR,Rn                     xtrct Rm,Rn
stc SR,Rn


ΓòÉΓòÉΓòÉ 17. Intel 80960 Dependent Features ΓòÉΓòÉΓòÉ

 Options-i960                            i960 Command-line Options
 Floating Point-i960                     Floating Point
 Directives-i960                         i960 Machine Directives
 Opcodes for i960                        i960 Opcodes


ΓòÉΓòÉΓòÉ 17.1. i960 Command-line Options ΓòÉΓòÉΓòÉ

 -ACA | -ACA_A | -ACB | -ACC | -AKA | -AKB | -AKC | -AMC
           Select the 80960 architecture.  Instructions or features not
           supported by the selected architecture cause fatal errors.

           `-ACA' is equivalent to `-ACA_A'; `-AKC' is equivalent to `-AMC'.
           Synonyms are provided for compatibility with other tools.

           If you do not specify any of these options, as generates code for
           any instruction or feature that is supported by some version of the
           960 (even if this means mixing architectures!).  In principle, as
           attempts to deduce the minimal sufficient processor type if none is
           specified; depending on the object code format, the processor type
           may be recorded in the object file.  If it is critical that the as
           output match a specific architecture, specify that architecture
           explicitly.

 -b
           Add code to collect information about conditional branches taken,
           for later optimization using branch prediction bits.  (The
           conditional branch instructions have branch prediction bits in the
           CA, CB, and CC architectures.)  If BR represents a conditional
           branch instruction, the following represents the code generated by
           the assembler when `-b' is specified:

                              call    increment routine
                              .word   0       # pre-counter
                      Label:  BR
                              call    increment routine
                              .word   0       # post-counter

           The counter following a branch records the number of times that
           branch was not taken; the differenc between the two counters is the
           number of times the branch was taken.

           A table of every such Label is also generated, so that the external
           postprocessor gbr960 (supplied by Intel) can locate all the
           counters.  This table is always labelled `__BRANCH_TABLE__'; this is
           a local symbol to permit collecting statistics for many separate
           object files.  The table is word aligned, and begins with a two-word
           header.  The first word, initialized to 0, is used in maintaining
           linked lists of branch tables.  The second word is a count of the
           number of entries in the table, which follow immediately: each is a
           word, pointing to one of the labels illustrated above.

                       +------------+------------+------------+ ... +------------+
                       |            |            |            |     |            |
                       |  *NEXT     |  COUNT: N  | *BRLAB 1   |     | *BRLAB N   |
                       |            |            |            |     |            |
                       +------------+------------+------------+ ... +------------+

                                     __BRANCH_TABLE__ layout

           The first word of the header is used to locate multiple branch
           tables, since each object file may contain one. Normally the links
           are maintained with a call to an initialization routine, placed at
           the beginning of each function in the file.  The gnu C compiler
           generates these calls automatically when you give it a `-b' option.
           For further details, see the documentation of `gbr960'.

 -norelax
           Normally, Compare-and-Branch instructions with targets that require
           displacements greater than 13 bits (or that have external targets)
           are replaced with the corresponding compare (or `chkbit') and branch
           instructions.  You can use the `-norelax' option to specify that as
           should generate errors instead, if the target displacement is larger
           than 13 bits.

           This option does not affect the Compare-and-Jump instructions; the
           code emitted for them is always adjusted when necessary (depending
           on displacement size), regardless of whether you use `-norelax'.


ΓòÉΓòÉΓòÉ 17.2. Floating Point ΓòÉΓòÉΓòÉ

as generates ieee floating-point numbers for the directives `.float',
`.double', `.extended', and `.single'.


ΓòÉΓòÉΓòÉ 17.3. i960 Machine Directives ΓòÉΓòÉΓòÉ

 .bss symbol, length, align
           Reserve length bytes in the bss section for a local symbol, aligned
           to the power of two specified by align.  length and align must be
           positive absolute expressions.  This directive differs from `.lcomm'
           only in that it permits you to specify an alignment.  See .lcomm.

 .extended flonums
           .extended expects zero or more flonums, separated by commas; for
           each flonum, `.extended' emits an ieee extended-format (80-bit)
           floating-point number.

 .leafproc call-lab, bal-lab
           You can use the `.leafproc' directive in conjunction with the
           optimized callj instruction to enable faster calls of leaf
           procedures.  If a procedure is known to call no other procedures,
           you may define an entry point that skips procedure prolog code (and
           that does not depend on system-supplied saved context), and declare
           it as the bal-lab using `.leafproc'.  If the procedure also has an
           entry point that goes through the normal prolog, you can specify
           that entry point as call-lab.

           A `.leafproc' declaration is meant for use in conjunction with the
           optimized call instruction `callj'; the directive records the data
           needed later to choose between converting the `callj' into a bal or
           a call.

           call-lab is optional; if only one argument is present, or if the two
           arguments are identical, the single argument is assumed to be the
           bal entry point.

 .sysproc name, index
           The `.sysproc' directive defines a name for a system procedure.
           After you define it using `.sysproc', you can use name to refer to
           the system procedure identified by index when calling procedures
           with the optimized call instruction `callj'.

           Both arguments are required; index must be between 0 and 31
           (inclusive).


ΓòÉΓòÉΓòÉ 17.4. i960 Opcodes ΓòÉΓòÉΓòÉ

All Intel 960 machine instructions are supported; see i960 Command-line Options
for a discussion of selecting the instruction subset for a particular 960
architecture.

Some opcodes are processed beyond simply emitting a single corresponding
instruction: `callj', and Compare-and-Branch or Compare-and-Jump instructions
with target displacements larger than 13 bits.

 callj-i960                              callj
 Compare-and-branch-i960                 Compare-and-Branch


ΓòÉΓòÉΓòÉ 17.4.1. callj ΓòÉΓòÉΓòÉ

You can write callj to have the assembler or the linker determine the most
appropriate form of subroutine call: `call', `bal', or `calls'.  If the
assembly source contains enough information---a `.leafproc' or `.sysproc'
directive defining the operand---then as translates the callj; if not, it
simply emits the callj, leaving it for the linker to resolve.


ΓòÉΓòÉΓòÉ 17.4.2. Compare-and-Branch ΓòÉΓòÉΓòÉ

The 960 architectures provide combined Compare-and-Branch instructions that
permit you to store the branch target in the lower 13 bits of the instruction
word itself.  However, if you specify a branch target far enough away that its
address won't fit in 13 bits, the assembler can either issue an error, or
convert your Compare-and-Branch instruction into separate instructions to do
the compare and the branch.

Whether as gives an error or expands the instruction depends on two choices you
can make: whether you use the `-norelax' option, and whether you use a
``Compare and Branch'' instruction or a ``Compare and Jump'' instruction.  The
``Jump'' instructions are always expanded if necessary; the ``Branch''
instructions are expanded when necessary unless you specify -norelax---in which
case as gives an error instead.

These are the Compare-and-Branch instructions, their ``Jump'' variants, and the
instruction pairs they may expand into:

        Compare and
     Branch      Jump       Expanded to
     ------    ------       ------------
        bbc                 chkbit; bno
        bbs                 chkbit; bo
     cmpibe    cmpije       cmpi; be
     cmpibg    cmpijg       cmpi; bg
    cmpibge   cmpijge       cmpi; bge
     cmpibl    cmpijl       cmpi; bl
    cmpible   cmpijle       cmpi; ble
    cmpibno   cmpijno       cmpi; bno
    cmpibne   cmpijne       cmpi; bne
     cmpibo    cmpijo       cmpi; bo
     cmpobe    cmpoje       cmpo; be
     cmpobg    cmpojg       cmpo; bg
    cmpobge   cmpojge       cmpo; bge
     cmpobl    cmpojl       cmpo; bl
    cmpoble   cmpojle       cmpo; ble
    cmpobne   cmpojne       cmpo; bne


ΓòÉΓòÉΓòÉ 18. M680x0 Dependent Features ΓòÉΓòÉΓòÉ

 M68K-Opts                               M680x0 Options
 M68K-Syntax                             Syntax
 M68K-Moto-Syntax                        Motorola Syntax
 M68K-Float                              Floating Point
 M68K-Directives                         680x0 Machine Directives
 M68K-opcodes                            Opcodes


ΓòÉΓòÉΓòÉ 18.1. M680x0 Options ΓòÉΓòÉΓòÉ

The Motorola 680x0 version of as has two machine dependent options. One
shortens undefined references from 32 to 16 bits, while the other is used to
tell as what kind of machine it is assembling for.

You can use the `-l' option to shorten the size of references to undefined
symbols.  If you do not use the `-l' option, references to undefined symbols
are wide enough for a full long (32 bits).  (Since as cannot know where these
symbols end up, as can only allocate space for the linker to fill in later.
Since as does not know how far away these symbols are, it allocates as much
space as it can.)  If you use this option, the references are only one word
wide (16 bits). This may be useful if you want the object file to be as small
as possible, and you know that the relevant symbols are always less than 17
bits away.

The 680x0 version of as is most frequently used to assemble programs for the
Motorola MC68020 microprocessor.  Occasionally it is used to assemble programs
for the mostly similar, but slightly different MC68000 or MC68010
microprocessors.  You can give as the options `-m68000', `-mc68000', `-m68010',
`-mc68010', `-m68020', and `-mc68020' to tell it what processor is the target.


ΓòÉΓòÉΓòÉ 18.2. Syntax ΓòÉΓòÉΓòÉ

This syntax for the Motorola 680x0 was developed at mit.

The 680x0 version of as uses syntax compatible with the Sun assembler.
Intervening periods are ignored; for example, `movl' is equivalent to `move.l'.

In the following table apc stands for any of the address registers (`a0'
through `a7'), nothing, (`'), the Program Counter (`pc'), or the zero-address
relative to the program counter (`zpc').

The following addressing modes are understood:

 Immediate
           `#digits'

 Data Register
           `d0' through `d7'

 Address Register
           `a0' through `a7'
           `a7' is also known as `sp', i.e. the Stack Pointer.  a6 is also
           known as `fp', the Frame Pointer.

 Address Register Indirect
           `a0@' through `a7@'

 Address Register Postincrement
           `a0@+' through `a7@+'

 Address Register Predecrement
           `a0@-' through `a7@-'

 Indirect Plus Offset
           `apc@(digits)'

 Index
           `apc@(digits,register:size:scale)'

           or `apc@(register:size:scale)'

 Postindex
           `apc@(digits)@(digits,register:size:scale)'

           or `apc@(digits)@(register:size:scale)'

 Preindex
           `apc@(digits,register:size:scale)@(digits)'

           or `apc@(register:size:scale)@(digits)'

 Memory Indirect
           `apc@(digits)@(digits)'

 Absolute
           `symbol', or `digits'

 For some configurations, especially those where the compiler normally does not
 prepend an underscore to the names of user variables, the assembler requires a
 `%' before any use of a register name.  This is intended to let the assembler
 distinguish between user variables and registers named `a0' through `a7', and
 so on.  The `%' is always accepted, but is only required for some
 configurations, notably `m68k-coff'.


ΓòÉΓòÉΓòÉ 18.3. Motorola Syntax ΓòÉΓòÉΓòÉ

The standard Motorola syntax for this chip differs from the syntax already
discussed (see Syntax).  as can accept both kinds of syntax, even within a
single instruction.  The two kinds of syntax are fully compatible.

In particular, you may write or generate M68K assembler with the following
conventions:

(In the following table apc stands for any of the address registers (`a0'
through `a7'), nothing, (`'), the Program Counter (`pc'), or the zero-address
relative to the program counter (`zpc').)

The following additional addressing modes are understood:

 Address Register Indirect
           `a0' through `a7'
           `a7' is also known as `sp', i.e. the Stack Pointer.  a6 is also
           known as `fp', the Frame Pointer.

 Address Register Postincrement
           `(a0)+' through `(a7)+'

 Address Register Predecrement
           `-(a0)' through `-(a7)'

 Indirect Plus Offset
           `digits(apc)'

 Index
           `digits(apc,(register.size*scale)'
           or `(apc,register.size*scale)'
           In either case, size and scale are optional (scale defaults to `1',
           size defaults to `l').  scale can be `1', `2', `4', or `8'.  size
           can be `w' or `l'.  scale is only supported on the 68020 and
           greater.


ΓòÉΓòÉΓòÉ 18.4. Floating Point ΓòÉΓòÉΓòÉ

The floating point code is not too well tested, and may have subtle bugs in it.

Packed decimal (P) format floating literals are not supported. Feel free to add
the code!

The floating point formats generated by directives are these.

 .float
           Single precision floating point constants.

 .double
           Double precision floating point constants.

 There is no directive to produce regions of memory holding extended precision
 numbers, however they can be used as immediate operands to floating-point
 instructions.  Adding a directive to create extended precision numbers would
 not be hard, but it has not yet seemed necessary.


ΓòÉΓòÉΓòÉ 18.5. 680x0 Machine Directives ΓòÉΓòÉΓòÉ

In order to be compatible with the Sun assembler the 680x0 assembler
understands the following directives.

 .data1
           This directive is identical to a .data 1 directive.

 .data2
           This directive is identical to a .data 2 directive.

 .even
           This directive is identical to a .align 1 directive.

 .skip
           This directive is identical to a .space directive.


ΓòÉΓòÉΓòÉ 18.6. Opcodes ΓòÉΓòÉΓòÉ

 M68K-Branch                             Branch Improvement
 M68K-Chars                              Special Characters


ΓòÉΓòÉΓòÉ 18.6.1. Branch Improvement ΓòÉΓòÉΓòÉ

Certain pseudo opcodes are permitted for branch instructions. They expand to
the shortest branch instruction that reach the target.  Generally these
mnemonics are made by substituting `j' for `b' at the start of a Motorola
mnemonic.

The following table summarizes the pseudo-operations.  A * flags cases that are
more fully described after the table:

          Displacement
          +-------------------------------------------------
          |                68020   68000/10
Pseudo-Op |BYTE    WORD    LONG    LONG      non-PC relative
          +-------------------------------------------------
     jbsr |bsrs    bsr     bsrl    jsr       jsr
      jra |bras    bra     bral    jmp       jmp
*     jXX |bXXs    bXX     bXXl    bNXs;jmpl bNXs;jmp
*    dbXX |dbXX    dbXX        dbXX; bra; jmpl
*    fjXX |fbXXw   fbXXw   fbXXl             fbNXw;jmp

XX: condition
NX: negative of condition XX

                         *---see full description below

 jbsr
 jra
           These are the simplest jump pseudo-operations; they always map to
           one particular machine instruction, depending on the displacement to
           the branch target.

 jXX
           Here, `jXX' stands for an entire family of pseudo-operations, where
           XX is a conditional branch or condition-code test.  The full list of
           pseudo-ops in this family is:

                       jhi   jls   jcc   jcs   jne   jeq   jvc
                       jvs   jpl   jmi   jge   jlt   jgt   jle

           For the cases of non-PC relative displacements and long
           displacements on the 68000 or 68010, as issues a longer code
           fragment in terms of NX, the opposite condition to XX.  For example,
           for the non-PC relative case:

                          jXX foo

           gives

                           bNXs oof
                           jmp foo
                       oof:

 dbXX
           The full family of pseudo-operations covered here is

                       dbhi   dbls   dbcc   dbcs   dbne   dbeq   dbvc
                       dbvs   dbpl   dbmi   dbge   dblt   dbgt   dble
                       dbf    dbra   dbt

           Other than for word and byte displacements, when the source reads
           `dbXX foo', as emits

                           dbXX oo1
                           bra oo2
                       oo1:jmpl foo
                       oo2:

 fjXX
           This family includes

                       fjne   fjeq   fjge   fjlt   fjgt   fjle   fjf
                       fjt    fjgl   fjgle  fjnge  fjngl  fjngle fjngt
                       fjnle  fjnlt  fjoge  fjogl  fjogt  fjole  fjolt
                       fjor   fjseq  fjsf   fjsne  fjst   fjueq  fjuge
                       fjugt  fjule  fjult  fjun

           For branch targets that are not PC relative, as emits

                           fbNX oof
                           jmp foo
                       oof:

           when it encounters `fjXX foo'.


ΓòÉΓòÉΓòÉ 18.6.2. Special Characters ΓòÉΓòÉΓòÉ

The immediate character is `#' for Sun compatibility.  The line-comment
character is `|'.  If a `#' appears at the beginning of a line, it is treated
as a comment unless it looks like `# line file', in which case it is treated
normally.


ΓòÉΓòÉΓòÉ 19. SPARC Dependent Features ΓòÉΓòÉΓòÉ

 Sparc-Opts                              Options
 Sparc-Float                             Floating Point
 Sparc-Directives                        Sparc Machine Directives


ΓòÉΓòÉΓòÉ 19.1. Options ΓòÉΓòÉΓòÉ

The SPARC chip family includes several successive levels (or other variants) of
chip, using the same core instruction set, but including a few additional
instructions at each level.

By default, as assumes the core instruction set (SPARC v6), but ``bumps'' the
architecture level as needed: it switches to successively higher architectures
as it encounters instructions that only exist in the higher levels.

 -Av6 | -Av7 | -Av8 | -Asparclite
           Use one of the `-A' options to select one of the SPARC architectures
           explicitly.  If you select an architecture explicitly, as reports a
           fatal error if it encounters an instruction or feature requiring a
           higher level.

 -bump
           Permit the assembler to ``bump'' the architecture level as required,
           but warn whenever it is necessary to switch to another level.


ΓòÉΓòÉΓòÉ 19.2. Floating Point ΓòÉΓòÉΓòÉ

The Sparc uses ieee floating-point numbers.


ΓòÉΓòÉΓòÉ 19.3. Sparc Machine Directives ΓòÉΓòÉΓòÉ

The Sparc version of as supports the following additional machine directives:

 .common
           This must be followed by a symbol name, a positive number, and
           "bss".  This behaves somewhat like .comm, but the syntax is
           different.

 .half
           This is functionally identical to .short.

 .proc
           This directive is ignored.  Any text following it on the same line
           is also ignored.

 .reserve
           This must be followed by a symbol name, a positive number, and
           "bss".  This behaves somewhat like .lcomm, but the syntax is
           different.

 .seg
           This must be followed by "text", "data", or "data1".  It behaves
           like .text, .data, or .data 1.

 .skip
           This is functionally identical to the .space directive.

 .word
           On the Sparc, the .word directive produces 32 bit values, instead of
           the 16 bit values it produces on many other machines.


ΓòÉΓòÉΓòÉ 20. 80386 Dependent Features ΓòÉΓòÉΓòÉ

 i386-Options                            Options
 i386-Syntax                             AT&T Syntax versus Intel Syntax
 i386-Opcodes                            Opcode Naming
 i386-Regs                               Register Naming
 i386-prefixes                           Opcode Prefixes
 i386-Memory                             Memory References
 i386-jumps                              Handling of Jump Instructions
 i386-Float                              Floating Point
 i386-Notes                              Notes


ΓòÉΓòÉΓòÉ 20.1. Options ΓòÉΓòÉΓòÉ

The 80386 has no machine dependent options.


ΓòÉΓòÉΓòÉ 20.2. AT&T Syntax versus Intel Syntax ΓòÉΓòÉΓòÉ

In order to maintain compatibility with the output of gcc, as supports AT&T
System V/386 assembler syntax.  This is quite different from Intel syntax.  We
mention these differences because almost all 80386 documents used only Intel
syntax.  Notable differences between the two syntaxes are:

     AT&T immediate operands are preceded by `$'; Intel immediate operands are
      undelimited (Intel `push 4' is AT&T `pushl $4'). AT&T register operands
      are preceded by `%'; Intel register operands are undelimited.  AT&T
      absolute (as opposed to PC relative) jump/call operands are prefixed by
      `*'; they are undelimited in Intel syntax.

     AT&T and Intel syntax use the opposite order for source and destination
      operands.  Intel `add eax, 4' is `addl $4, %eax'.  The `source, dest'
      convention is maintained for compatibility with previous Unix assemblers.

     In AT&T syntax the size of memory operands is determined from the last
      character of the opcode name.  Opcode suffixes of `b', `w', and `l'
      specify byte (8-bit), word (16-bit), and long (32-bit) memory references.
      Intel syntax accomplishes this by prefixes memory operands (not the
      opcodes themselves) with `byte ptr', `word ptr', and `dword ptr'.  Thus,
      Intel `mov al, byte ptr foo' is `movb foo, %al' in AT&T syntax.

     Immediate form long jumps and calls are `lcall/ljmp $section, $offset' in
      AT&T syntax; the Intel syntax is `call/jmp far section:offset'.  Also,
      the far return instruction is `lret $stack-adjust' in AT&T syntax; Intel
      syntax is `ret far stack-adjust'.

     The AT&T assembler does not provide support for multiple section
      programs.  Unix style systems expect all programs to be single sections.


ΓòÉΓòÉΓòÉ 20.3. Opcode Naming ΓòÉΓòÉΓòÉ

Opcode names are suffixed with one character modifiers which specify the size
of operands.  The letters `b', `w', and `l' specify byte, word, and long
operands.  If no suffix is specified by an instruction and it contains no
memory operands then as tries to fill in the missing suffix based on the
destination register operand (the last one by convention).  Thus, `mov %ax,
%bx' is equivalent to `movw %ax, %bx'; also, `mov $1, %bx' is equivalent to
`movw $1, %bx'.  Note that this is incompatible with the AT&T Unix assembler
which assumes that a missing opcode suffix implies long operand size.  (This
incompatibility does not affect compiler output since compilers always
explicitly specify the opcode suffix.)

Almost all opcodes have the same names in AT&T and Intel format.  There are a
few exceptions.  The sign extend and zero extend instructions need two sizes to
specify them.  They need a size to sign/zero extend from and a size to zero
extend to.  This is accomplished by using two opcode suffixes in AT&T syntax.
Base names for sign extend and zero extend are `movs...' and `movz...' in AT&T
syntax (`movsx' and `movzx' in Intel syntax).  The opcode suffixes are tacked
on to this base name, the from suffix before the to suffix.  Thus, `movsbl %al,
%edx' is AT&T syntax for ``move sign extend from %al to %edx.''  Possible
suffixes, thus, are `bl' (from byte to long), `bw' (from byte to word), and
`wl' (from word to long).

The Intel-syntax conversion instructions

     `cbw' --- sign-extend byte in `%al' to word in `%ax',

     `cwde' --- sign-extend word in `%ax' to long in `%eax',

     `cwd' --- sign-extend word in `%ax' to long in `%dx:%ax',

     `cdq' --- sign-extend dword in `%eax' to quad in `%edx:%eax',

 are called `cbtw', `cwtl', `cwtd', and `cltd' in AT&T naming.  as accepts
 either naming for these instructions.

 Far call/jump instructions are `lcall' and `ljmp' in AT&T syntax, but are
 `call far' and `jump far' in Intel convention.


ΓòÉΓòÉΓòÉ 20.4. Register Naming ΓòÉΓòÉΓòÉ

Register operands are always prefixes with `%'.  The 80386 registers consist of

     the 8 32-bit registers `%eax' (the accumulator), `%ebx', `%ecx', `%edx',
      `%edi', `%esi', `%ebp' (the frame pointer), and `%esp' (the stack
      pointer).

     the 8 16-bit low-ends of these: `%ax', `%bx', `%cx', `%dx', `%di', `%si',
      `%bp', and `%sp'.

     the 8 8-bit registers: `%ah', `%al', `%bh', `%bl', `%ch', `%cl', `%dh',
      and `%dl' (These are the high-bytes and low-bytes of `%ax', `%bx', `%cx',
      and `%dx')

     the 6 section registers `%cs' (code section), `%ds' (data section), `%ss'
      (stack section), `%es', `%fs', and `%gs'.

     the 3 processor control registers `%cr0', `%cr2', and `%cr3'.

     the 6 debug registers `%db0', `%db1', `%db2', `%db3', `%db6', and `%db7'.

     the 2 test registers `%tr6' and `%tr7'.

     the 8 floating point register stack `%st' or equivalently `%st(0)',
      `%st(1)', `%st(2)', `%st(3)', `%st(4)', `%st(5)', `%st(6)', and `%st(7)'.


ΓòÉΓòÉΓòÉ 20.5. Opcode Prefixes ΓòÉΓòÉΓòÉ

Opcode prefixes are used to modify the following opcode.  They are used to
repeat string instructions, to provide section overrides, to perform bus lock
operations, and to give operand and address size (16-bit operands are specified
in an instruction by prefixing what would normally be 32-bit operands with a
``operand size'' opcode prefix). Opcode prefixes are usually given as
single-line instructions with no operands, and must directly precede the
instruction they act upon.  For example, the `scas' (scan string) instruction
is repeated with:

        repne
        scas

Here is a list of opcode prefixes:

     Section override prefixes `cs', `ds', `ss', `es', `fs', `gs'.  These are
      automatically added by specifying using the section:memory-operand form
      for memory references.

     Operand/Address size prefixes `data16' and `addr16' change 32-bit
      operands/addresses into 16-bit operands/addresses.  Note that 16-bit
      addressing modes (i.e. 8086 and 80286 addressing modes) are not supported
      (yet).

     The bus lock prefix `lock' inhibits interrupts during execution of the
      instruction it precedes.  (This is only valid with certain instructions;
      see a 80386 manual for details).

     The wait for coprocessor prefix `wait' waits for the coprocessor to
      complete the current instruction.  This should never be needed for the
      80386/80387 combination.

     The `rep', `repe', and `repne' prefixes are added to string instructions
      to make them repeat `%ecx' times.


ΓòÉΓòÉΓòÉ 20.6. Memory References ΓòÉΓòÉΓòÉ

An Intel syntax indirect memory reference of the form

section:[base + index*scale + disp]

is translated into the AT&T syntax

section:disp(base, index, scale)

where base and index are the optional 32-bit base and index registers, disp is
the optional displacement, and scale, taking the values 1, 2, 4, and 8,
multiplies index to calculate the address of the operand.  If no scale is
specified, scale is taken to be 1.  section specifies the optional section
register for the memory operand, and may override the default section register
(see a 80386 manual for section register defaults). Note that section overrides
in AT&T syntax must have be preceded by a `%'.  If you specify a section
override which coincides with the default section register, as does not output
any section register override prefixes to assemble the given instruction.
Thus, section overrides can be specified to emphasize which section register is
used for a given memory operand.

Here are some examples of Intel and AT&T style memory references:

 AT&T: `-4(%ebp)', Intel:  `[ebp - 4]'
           base is `%ebp'; disp is `-4'. section is missing, and the default
           section is used (`%ss' for addressing with `%ebp' as the base
           register).  index, scale are both missing.

 AT&T: `foo(,%eax,4)', Intel: `[foo + eax*4]'
           index is `%eax' (scaled by a scale 4); disp is `foo'.  All other
           fields are missing.  The section register here defaults to `%ds'.

 AT&T: `foo(,1)'; Intel `[foo]'
           This uses the value pointed to by `foo' as a memory operand. Note
           that base and index are both missing, but there is only one `,'.
           This is a syntactic exception.

 AT&T: `%gs:foo'; Intel `gs:foo'
           This selects the contents of the variable `foo' with section
           register section being `%gs'.

 Absolute (as opposed to PC relative) call and jump operands must be prefixed
 with `*'.  If no `*' is specified, as always chooses PC relative addressing
 for jump/call labels.

 Any instruction that has a memory operand must specify its size (byte, word,
 or long) with an opcode suffix (`b', `w', or `l', respectively).


ΓòÉΓòÉΓòÉ 20.7. Handling of Jump Instructions ΓòÉΓòÉΓòÉ

Jump instructions are always optimized to use the smallest possible
displacements.  This is accomplished by using byte (8-bit) displacement jumps
whenever the target is sufficiently close.  If a byte displacement is
insufficient a long (32-bit) displacement is used.  We do not support word
(16-bit) displacement jumps (i.e. prefixing the jump instruction with the
`addr16' opcode prefix), since the 80386 insists upon masking `%eip' to 16 bits
after the word displacement is added.

Note that the `jcxz', `jecxz', `loop', `loopz', `loope', `loopnz' and `loopne'
instructions only come in byte displacements, so that if you use these
instructions (gcc does not use them) you may get an error message (and
incorrect code).  The AT&T 80386 assembler tries to get around this problem by
expanding `jcxz foo' to

         jcxz cx_zero
         jmp cx_nonzero
cx_zero: jmp foo
cx_nonzero:


ΓòÉΓòÉΓòÉ 20.8. Floating Point ΓòÉΓòÉΓòÉ

All 80387 floating point types except packed BCD are supported. (BCD support
may be added without much difficulty).  These data types are 16-, 32-, and 64-
bit integers, and single (32-bit), double (64-bit), and extended (80-bit)
precision floating point. Each supported type has an opcode suffix and a
constructor associated with it.  Opcode suffixes specify operand's data types.
Constructors build these data types into memory.

     Floating point constructors are `.float' or `.single', `.double', and
      `.tfloat' for 32-, 64-, and 80-bit formats. These correspond to opcode
      suffixes `s', `l', and `t'. `t' stands for temporary real, and that the
      80387 only supports this format via the `fldt' (load temporary real to
      stack top) and `fstpt' (store temporary real and pop stack) instructions.

     Integer constructors are `.word', `.long' or `.int', and `.quad' for the
      16-, 32-, and 64-bit integer formats.  The corresponding opcode suffixes
      are `s' (single), `l' (long), and `q' (quad).  As with the temporary real
      format the 64-bit `q' format is only present in the `fildq' (load quad
      integer to stack top) and `fistpq' (store quad integer and pop stack)
      instructions.

 Register to register operations do not require opcode suffixes, so that `fst
 %st, %st(1)' is equivalent to `fstl %st, %st(1)'.

 Since the 80387 automatically synchronizes with the 80386 `fwait' instructions
 are almost never needed (this is not the case for the 80286/80287 and
 8086/8087 combinations).  Therefore, as suppresses the `fwait' instruction
 whenever it is implicitly selected by one of the `fn...' instructions.  For
 example, `fsave' and `fnsave' are treated identically.  In general, all the
 `fn...' instructions are made equivalent to `f...' instructions.  If `fwait'
 is desired it must be explicitly coded.


ΓòÉΓòÉΓòÉ 20.9. Notes ΓòÉΓòÉΓòÉ

There is some trickery concerning the `mul' and `imul' instructions that
deserves mention.  The 16-, 32-, and 64-bit expanding multiplies (base opcode
`0xf6'; extension 4 for `mul' and 5 for `imul') can be output only in the one
operand form.  Thus, `imul %ebx, %eax' does not select the expanding multiply;
the expanding multiply would clobber the `%edx' register, and this would
confuse gcc output.  Use `imul %ebx' to get the 64-bit product in `%edx:%eax'.

We have added a two operand form of `imul' when the first operand is an
immediate mode expression and the second operand is a register. This is just a
shorthand, so that, multiplying `%eax' by 69, for example, can be done with
`imul $69, %eax' rather than `imul $69, %eax, %eax'.


ΓòÉΓòÉΓòÉ 21. Z8000 Dependent Features ΓòÉΓòÉΓòÉ

The Z8000 as supports both members of the Z8000 family: the unsegmented Z8002,
with 16 bit addresses, and the segmented Z8001 with 24 bit addresses.

When the assembler is in unsegmented mode (specified with the unsegm
directive), an address takes up one word (16 bit) sized register.  When the
assembler is in segmented mode (specified with the segm directive), a 24-bit
address takes up a long (32 bit) register.  See Assembler Directives for the
Z8000, for a list of other Z8000 specific assembler directives.

 Z8000 Options                           No special command-line options for
                                         Z8000
 Z8000 Syntax                            Assembler syntax for the Z8000
 Z8000 Directives                        Special directives for the Z8000
 Z8000 Opcodes                           Opcodes


ΓòÉΓòÉΓòÉ 21.1. Options ΓòÉΓòÉΓòÉ

as has no additional command-line options for the Zilog Z8000 family.


ΓòÉΓòÉΓòÉ 21.2. Syntax ΓòÉΓòÉΓòÉ

 Z8000-Chars                             Special Characters
 Z8000-Regs                              Register Names
 Z8000-Addressing                        Addressing Modes


ΓòÉΓòÉΓòÉ 21.2.1. Special Characters ΓòÉΓòÉΓòÉ

`!' is the line comment character.

You can use `;' instead of a newline to separate statements.


ΓòÉΓòÉΓòÉ 21.2.2. Register Names ΓòÉΓòÉΓòÉ

The Z8000 has sixteen 16 bit registers, numbered 0 to 15.  You can refer to
different sized groups of registers by register number, with the prefix `r' for
16 bit registers, `rr' for 32 bit registers and `rq' for 64 bit registers.  You
can also refer to the contents of the first eight (of the sixteen 16 bit
registers) by bytes.  They are named `rnh' and `rnl'.

byte registers
r0l r0h r1h r1l r2h r2l r3h r3l
r4h r4l r5h r5l r6h r6l r7h r7l

word registers
r0 r1 r2 r3 r4 r5 r6 r7 r8 r9 r10 r11 r12 r13 r14 r15

long word registers
rr0 rr2 rr4 rr6 rr8 rr10 rr12 rr14

quad word registers
rq0 rq4 rq8 rq12


ΓòÉΓòÉΓòÉ 21.2.3. Addressing Modes ΓòÉΓòÉΓòÉ

as understands the following addressing modes for the Z8000:

 rn
           Register direct

 @rn
           Indirect register

 addr
           Direct: the 16 bit or 24 bit address (depending on whether the
           assembler is in segmented or unsegmented mode) of the operand is in
           the instruction.

 address(rn)
           Indexed: the 16 or 24 bit address is added to the 16 bit register to
           produce the final address in memory of the operand.

 rn(#imm)
           Base Address: the 16 or 24 bit register is added to the 16 bit sign
           extended immediate displacement to produce the final address in
           memory of the operand.

 rn(rm)
           Base Index: the 16 or 24 bit register rn is added to the sign
           extended 16 bit index register rm to produce the final address in
           memory of the operand.

 #xx
           Immediate data xx.


ΓòÉΓòÉΓòÉ 21.3. Assembler Directives for the Z8000 ΓòÉΓòÉΓòÉ

The Z8000 port of as includes these additional assembler directives, for
compatibility with other Z8000 assemblers.  As shown, these do not begin with
`.' (unlike the ordinary as directives).

 segm
           Generates code for the segmented Z8001.

 unsegm
           Generates code for the unsegmented Z8002.

 name
           Synonym for .file

 global
           Synonum for .global

 wval
           Synonym for .word

 lval
           Synonym for .long

 bval
           Synonym for .byte

 sval
           Assemble a string.  sval expects one string literal, delimited by
           single quotes.  It assembles each byte of the string into
           consecutive addresses.  You can use the escape sequence `%xx' (where
           xx represents a two-digit hexadecimal number) to represent the
           character whose ascii value is xx.  Use this feature to describe
           single quote and other characters that may not appear in string
           literals as themselves.  For example, the C statement `char *a = "he
           said \"it's 50% off\"";' is represented in Z8000 assembly language
           (shown with the assembler output in hex at the left) as

                      68652073    sval    'he said %22it%27s 50%25 off%22%00'
                      61696420
                      22697427
                      73203530
                      25206F66
                      662200

 rsect
           synonym for .section

 block
           synonym for .space

 even
           synonym for .align 1


ΓòÉΓòÉΓòÉ 21.4. Opcodes ΓòÉΓòÉΓòÉ

For detailed information on the Z8000 machine instruction set, see Z8000
Technical Manual.

The following table summarizes the opcodes and their arguments:


            rs   16 bit source register
            rd   16 bit destination register
            rbs   8 bit source register
            rbd   8 bit destination register
            rrs   32 bit source register
            rrd   32 bit destination register
            rqs   64 bit source register
            rqd   64 bit destination register
            addr 16/24 bit address
            imm  immediate data

adc rd,rs               clrb addr               cpsir @rd,@rs,rr,cc
adcb rbd,rbs            clrb addr(rd)           cpsirb @rd,@rs,rr,cc
add rd,@rs              clrb rbd                dab rbd
add rd,addr             com @rd                 dbjnz rbd,disp7
add rd,addr(rs)         com addr                dec @rd,imm4m1
add rd,imm16            com addr(rd)            dec addr(rd),imm4m1
add rd,rs               com rd                  dec addr,imm4m1
addb rbd,@rs            comb @rd                dec rd,imm4m1
addb rbd,addr           comb addr               decb @rd,imm4m1
addb rbd,addr(rs)       comb addr(rd)           decb addr(rd),imm4m1
addb rbd,imm8           comb rbd                decb addr,imm4m1
addb rbd,rbs            comflg flags            decb rbd,imm4m1
addl rrd,@rs            cp @rd,imm16            di i2
addl rrd,addr           cp addr(rd),imm16       div rrd,@rs
addl rrd,addr(rs)       cp addr,imm16           div rrd,addr
addl rrd,imm32          cp rd,@rs               div rrd,addr(rs)
addl rrd,rrs            cp rd,addr              div rrd,imm16
and rd,@rs              cp rd,addr(rs)          div rrd,rs
and rd,addr             cp rd,imm16             divl rqd,@rs
and rd,addr(rs)         cp rd,rs                divl rqd,addr
and rd,imm16            cpb @rd,imm8            divl rqd,addr(rs)
and rd,rs               cpb addr(rd),imm8       divl rqd,imm32
andb rbd,@rs            cpb addr,imm8           divl rqd,rrs
andb rbd,addr           cpb rbd,@rs             djnz rd,disp7
andb rbd,addr(rs)       cpb rbd,addr            ei i2
andb rbd,imm8           cpb rbd,addr(rs)        ex rd,@rs
andb rbd,rbs            cpb rbd,imm8            ex rd,addr
bit @rd,imm4            cpb rbd,rbs             ex rd,addr(rs)
bit addr(rd),imm4       cpd rd,@rs,rr,cc        ex rd,rs
bit addr,imm4           cpdb rbd,@rs,rr,cc      exb rbd,@rs
bit rd,imm4             cpdr rd,@rs,rr,cc       exb rbd,addr
bit rd,rs               cpdrb rbd,@rs,rr,cc     exb rbd,addr(rs)
bitb @rd,imm4           cpi rd,@rs,rr,cc        exb rbd,rbs
bitb addr(rd),imm4      cpib rbd,@rs,rr,cc      ext0e imm8
bitb addr,imm4          cpir rd,@rs,rr,cc       ext0f imm8
bitb rbd,imm4           cpirb rbd,@rs,rr,cc     ext8e imm8
bitb rbd,rs             cpl rrd,@rs             ext8f imm8
bpt                     cpl rrd,addr            exts rrd
call @rd                cpl rrd,addr(rs)        extsb rd
call addr               cpl rrd,imm32           extsl rqd
call addr(rd)           cpl rrd,rrs             halt
calr disp12             cpsd @rd,@rs,rr,cc      in rd,@rs
clr @rd                 cpsdb @rd,@rs,rr,cc     in rd,imm16
clr addr                cpsdr @rd,@rs,rr,cc     inb rbd,@rs
clr addr(rd)            cpsdrb @rd,@rs,rr,cc    inb rbd,imm16
clr rd                  cpsi @rd,@rs,rr,cc      inc @rd,imm4m1
clrb @rd                cpsib @rd,@rs,rr,cc     inc addr(rd),imm4m1
inc addr,imm4m1         ldb rbd,rs(rx)          mult rrd,addr(rs)
inc rd,imm4m1           ldb rd(imm16),rbs       mult rrd,imm16
incb @rd,imm4m1         ldb rd(rx),rbs          mult rrd,rs
incb addr(rd),imm4m1    ldctl ctrl,rs           multl rqd,@rs
incb addr,imm4m1        ldctl rd,ctrl           multl rqd,addr
incb rbd,imm4m1         ldd @rs,@rd,rr          multl rqd,addr(rs)
ind @rd,@rs,ra          lddb @rs,@rd,rr         multl rqd,imm32
indb @rd,@rs,rba        lddr @rs,@rd,rr         multl rqd,rrs
inib @rd,@rs,ra         lddrb @rs,@rd,rr        neg @rd
inibr @rd,@rs,ra        ldi @rd,@rs,rr          neg addr
iret                    ldib @rd,@rs,rr         neg addr(rd)
jp cc,@rd               ldir @rd,@rs,rr         neg rd
jp cc,addr              ldirb @rd,@rs,rr        negb @rd
jp cc,addr(rd)          ldk rd,imm4             negb addr
jr cc,disp8             ldl @rd,rrs             negb addr(rd)
ld @rd,imm16            ldl addr(rd),rrs        negb rbd
ld @rd,rs               ldl addr,rrs            nop
ld addr(rd),imm16       ldl rd(imm16),rrs       or rd,@rs
ld addr(rd),rs          ldl rd(rx),rrs          or rd,addr
ld addr,imm16           ldl rrd,@rs             or rd,addr(rs)
ld addr,rs              ldl rrd,addr            or rd,imm16
ld rd(imm16),rs         ldl rrd,addr(rs)        or rd,rs
ld rd(rx),rs            ldl rrd,imm32           orb rbd,@rs
ld rd,@rs               ldl rrd,rrs             orb rbd,addr
ld rd,addr              ldl rrd,rs(imm16)       orb rbd,addr(rs)
ld rd,addr(rs)          ldl rrd,rs(rx)          orb rbd,imm8
ld rd,imm16             ldm @rd,rs,n            orb rbd,rbs
ld rd,rs                ldm addr(rd),rs,n       out @rd,rs
ld rd,rs(imm16)         ldm addr,rs,n           out imm16,rs
ld rd,rs(rx)            ldm rd,@rs,n            outb @rd,rbs
lda rd,addr             ldm rd,addr(rs),n       outb imm16,rbs
lda rd,addr(rs)         ldm rd,addr,n           outd @rd,@rs,ra
lda rd,rs(imm16)        ldps @rs                outdb @rd,@rs,rba
lda rd,rs(rx)           ldps addr               outib @rd,@rs,ra
ldar rd,disp16          ldps addr(rs)           outibr @rd,@rs,ra
ldb @rd,imm8            ldr disp16,rs           pop @rd,@rs
ldb @rd,rbs             ldr rd,disp16           pop addr(rd),@rs
ldb addr(rd),imm8       ldrb disp16,rbs         pop addr,@rs
ldb addr(rd),rbs        ldrb rbd,disp16         pop rd,@rs
ldb addr,imm8           ldrl disp16,rrs         popl @rd,@rs
ldb addr,rbs            ldrl rrd,disp16         popl addr(rd),@rs
ldb rbd,@rs             mbit                    popl addr,@rs
ldb rbd,addr            mreq rd                 popl rrd,@rs
ldb rbd,addr(rs)        mres                    push @rd,@rs
ldb rbd,imm8            mset                    push @rd,addr
ldb rbd,rbs             mult rrd,@rs            push @rd,addr(rs)
ldb rbd,rs(imm16)       mult rrd,addr           push @rd,imm16
push @rd,rs             set addr,imm4           subl rrd,imm32
pushl @rd,@rs           set rd,imm4             subl rrd,rrs
pushl @rd,addr          set rd,rs               tcc cc,rd
pushl @rd,addr(rs)      setb @rd,imm4           tccb cc,rbd
pushl @rd,rrs           setb addr(rd),imm4      test @rd
res @rd,imm4            setb addr,imm4          test addr
res addr(rd),imm4       setb rbd,imm4           test addr(rd)
res addr,imm4           setb rbd,rs             test rd
res rd,imm4             setflg imm4             testb @rd
res rd,rs               sinb rbd,imm16          testb addr
resb @rd,imm4           sinb rd,imm16           testb addr(rd)
resb addr(rd),imm4      sind @rd,@rs,ra         testb rbd
resb addr,imm4          sindb @rd,@rs,rba       testl @rd
resb rbd,imm4           sinib @rd,@rs,ra        testl addr
resb rbd,rs             sinibr @rd,@rs,ra       testl addr(rd)
resflg imm4             sla rd,imm8             testl rrd
ret cc                  slab rbd,imm8           trdb @rd,@rs,rba
rl rd,imm1or2           slal rrd,imm8           trdrb @rd,@rs,rba
rlb rbd,imm1or2         sll rd,imm8             trib @rd,@rs,rbr
rlc rd,imm1or2          sllb rbd,imm8           trirb @rd,@rs,rbr
rlcb rbd,imm1or2        slll rrd,imm8           trtdrb @ra,@rb,rbr
rldb rbb,rba            sout imm16,rs           trtib @ra,@rb,rr
rr rd,imm1or2           soutb imm16,rbs         trtirb @ra,@rb,rbr
rrb rbd,imm1or2         soutd @rd,@rs,ra        trtrb @ra,@rb,rbr
rrc rd,imm1or2          soutdb @rd,@rs,rba      tset @rd
rrcb rbd,imm1or2        soutib @rd,@rs,ra       tset addr
rrdb rbb,rba            soutibr @rd,@rs,ra      tset addr(rd)
rsvd36                  sra rd,imm8             tset rd
rsvd38                  srab rbd,imm8           tsetb @rd
rsvd78                  sral rrd,imm8           tsetb addr
rsvd7e                  srl rd,imm8             tsetb addr(rd)
rsvd9d                  srlb rbd,imm8           tsetb rbd
rsvd9f                  srll rrd,imm8           xor rd,@rs
rsvdb9                  sub rd,@rs              xor rd,addr
rsvdbf                  sub rd,addr             xor rd,addr(rs)
sbc rd,rs               sub rd,addr(rs)         xor rd,imm16
sbcb rbd,rbs            sub rd,imm16            xor rd,rs
sc imm8                 sub rd,rs               xorb rbd,@rs
sda rd,rs               subb rbd,@rs            xorb rbd,addr
sdab rbd,rs             subb rbd,addr           xorb rbd,addr(rs)
sdal rrd,rs             subb rbd,addr(rs)       xorb rbd,imm8
sdl rd,rs               subb rbd,imm8           xorb rbd,rbs
sdlb rbd,rs             subb rbd,rbs            xorb rbd,rbs
sdll rrd,rs             subl rrd,@rs
set @rd,imm4            subl rrd,addr
set addr(rd),imm4       subl rrd,addr(rs)


ΓòÉΓòÉΓòÉ 22. MIPS Dependent Features ΓòÉΓòÉΓòÉ

gnu as for mips architectures supports the mips r2000, r3000, r4000 and r6000
processors.  For information about the mips instruction set, see MIPS RISC
Architecture, by Kane and Heindrich (Prentice-Hall).  For an overview of mips
assembly conventions, see ``Appendix D: Assembly Language Programming'' in the
same work.

 MIPS Opts                               Assembler options
 MIPS Object                             ECOFF object code
 MIPS Stabs                              Directives for debugging information
 MIPS ISA                                Directives to override the ISA level


ΓòÉΓòÉΓòÉ 22.1. Assembler options ΓòÉΓòÉΓòÉ

The mips configurations of gnu as support these special options:

 -G num
           This option sets the largest size of an object that can be
           referenced implicitly with the gp register.  It is only accepted for
           targets that use ecoff format.  The default value is 8.

 -EB
 -EL
           Any mips configuration of as can select big-endian or little-endian
           output at run time (unlike the other gnu development tools, which
           must be configured for one or the other).  Use `-EB' to select
           big-endian output, and `-EL' for little-endian.

 -mips1
 -mips2
 -mips3
           Generate code for a particular MIPS Instruction Set Architecture
           level. `-mips1' corresponds to the r2000 and r3000 processors,
           `-mips2' to the r6000 processor, and `-mips3' to the r4000
           processor.  You can also switch instruction sets during the
           assembly; see Directives to override the ISA level.

 -nocpp
           This option is ignored.  It is accepted for command-line
           compatibility with other assemblers, which use it to turn off C
           style preprocessing.  With gnu as, there is no need for `-nocpp',
           because the gnu assembler itself never runs the C preprocessor.

 --trap
 --no-break
           as automatically macro expands certain division and multiplication
           instructions to check for overflow and division by zero.  This
           option causes as to generate code to take a trap exception rather
           than a break exception when an error is detected.  The trap
           instructions are only supported at Instruction Set Architecture
           level 2 and higher.

 --break
 --no-trap
           Generate code to take a break exception rather than a trap exception
           when an error is detected.  This is the default.


ΓòÉΓòÉΓòÉ 22.2. MIPS ECOFF object code ΓòÉΓòÉΓòÉ

Assembling for a mips ecoff target supports some additional sections besides
the usual .text, .data and .bss.  The additional sections are .rdata, used for
read-only data, .sdata, used for small data, and .sbss, used for small common
objects.

When assembling for ecoff, the assembler uses the $gp ($28) register to form
the address of a ``small object''.  Any object in the .sdata or .sbss sections
is considered ``small'' in this sense. For external objects, or for objects in
the .bss section, you can use the gcc `-G' option to control the size of
objects addressed via $gp; the default value is 8, meaning that a reference to
any object eight bytes or smaller uses $gp.  Passing `-G 0' to as prevents it
from using the $gp register on the basis of object size (but the assembler uses
$gp for objects in .sdata or sbss in any case).  The size of an object in the
.bss section is set by the .comm or .lcomm directive that defines it.  The size
of an external object may be set with the .extern directive.  For example,
`.extern sym,4' declares that the object at sym is 4 bytes in length, whie
leaving sym otherwise undefined.

Using small ecoff objects requires linker support, and assumes that the $gp
register is correctly initialized (normally done automatically by the startup
code).  mips ecoff assembly code must not modify the $gp register.


ΓòÉΓòÉΓòÉ 22.3. Directives for debugging information ΓòÉΓòÉΓòÉ

mips ecoff as supports several directives used for generating debugging
information which are not support by traditional mips assemblers.  These are
.def, .endef, .dim, .file, .scl, .size, .tag, .type, .val, .stabd, .stabn, and
.stabs.  The debugging information generated by the three .stab directives can
only be read by gdb, not by traditional mips debuggers (this enhancement is
required to fully support C++ debugging).  These directives are primarily used
by compilers, not assembly language programmers!


ΓòÉΓòÉΓòÉ 22.4. Directives to override the ISA level ΓòÉΓòÉΓòÉ

gnu as supports an additional directive to change the mips Instruction Set
Architecture level on the fly: .set mipsn.  n should be a number from 0 to 3.
A value from 1 to 3 makes the assembler accept instructions for the
corresponding isa level, from that point on in the assembly.  .set mipsn
affects not only which instructions are permitted, but also how certain macros
are expanded. .set mips0 restores the isa level to its original level: either
the level you selected with command line options, or the default for your
configuration.  You can use this feature to permit specific r4000 instructions
while assembling in 32 bit mode.  Use this directive with care!

Traditional mips assemblers do not support this directive.


ΓòÉΓòÉΓòÉ 23. Acknowledgements ΓòÉΓòÉΓòÉ

If you have contributed to as and your name isn't listed here, it is not meant
as a slight.  We just don't know about it.  Send mail to the maintainer, and
we'll correct the situation.  Currently (January 1994), the maintainer is Ken
Raeburn (email address [e-mail]).

Dean Elsner wrote the original gnu assembler for the VAX.(1)

Jay Fenlason maintained GAS for a while, adding support for GDB-specific debug
information and the 68k series machines, most of the preprocessing pass, and
extensive changes in `messages.c', `input-file.c', `write.c'.

K. Richard Pixley maintained GAS for a while, adding various enhancements and
many bug fixes, including merging support for several processors, breaking GAS
up to handle multiple object file format back ends (including heavy rewrite,
testing, an integration of the coff and b.out back ends), adding configuration
including heavy testing and verification of cross assemblers and file splits
and renaming, converted GAS to strictly ANSI C including full prototypes, added
support for m680[34]0 and cpu32, did considerable work on i960 including a COFF
port (including considerable amounts of reverse engineering), a SPARC opcode
file rewrite, DECstation, rs6000, and hp300hpux host ports, updated ``know''
assertions and made them work, much other reorganization, cleanup, and lint.

Ken Raeburn wrote the high-level BFD interface code to replace most of the code
in format-specific I/O modules.

The original VMS support was contributed by David L. Kashtan.  Eric Youngdale
has done much work with it since.

The Intel 80386 machine description was written by Eliot Dresselhaus.

Minh Tran-Le at IntelliCorp contributed some AIX 386 support.

The Motorola 88k machine description was contributed by Devon Bowen of Buffalo
University and Torbjorn Granlund of the Swedish Institute of Computer Science.

Keith Knowles at the Open Software Foundation wrote the original MIPS back end
(`tc-mips.c', `tc-mips.h'), and contributed Rose format support (which hasn't
been merged in yet).  Ralph Campbell worked with the MIPS code to support a.out
format.

Support for the Zilog Z8k and Hitachi H8/300 and H8/500 processors (tc-z8k,
tc-h8300, tc-h8500), and IEEE 695 object file format (obj-ieee), was written by
Steve Chamberlain of Cygnus Support.  Steve also modified the COFF back end to
use BFD for some low-level operations, for use with the H8/300 and AMD 29k
targets.

John Gilmore built the AMD 29000 support, added .include support, and
simplified the configuration of which versions accept which directives.  He
updated the 68k machine description so that Motorola's opcodes always produced
fixed-size instructions (e.g. jsr), while synthetic instructions remained
shrinkable (jbsr).  John fixed many bugs, including true tested
cross-compilation support, and one bug in relaxation that took a week and
required the proverbial one-bit fix.

Ian Lance Taylor of Cygnus Support merged the Motorola and MIT syntax for the
68k, completed support for some COFF targets (68k, i386 SVR3, and SCO Unix),
added support for MIPS ECOFF and ELF targets, and made a few other minor
patches.

Steve Chamberlain made as able to generate listings.

Hewlett-Packard contributed support for the HP9000/300.

Jeff Law wrote GAS and BFD support for the native HPPA object format (SOM)
along with a fairly extensive HPPA testsuite (for both SOM and ELF object
formats).  This work was supported by both the Center for Software Science at
the University of Utah and Cygnus Support.

Support for ELF format files has been worked on by Mark Eichin of Cygnus
Support (original, incomplete implementation for SPARC), Pete Hoogenboom and
Jeff Law at the University of Utah (HPPA mainly), Michael Meissner of the Open
Software Foundation (i386 mainly), and Ken Raeburn of Cygnus Support (sparc,
and some initial 64-bit support).

Several engineers at Cygnus Support have also provided many small bug fixes and
configuration enhancements.

Many others have contributed large or small bugfixes and enhancements.  If you
have contributed significant work and are not mentioned on this list, and want
to be, let us know.  Some of the history has been lost; we are not
intentionally leaving anyone out.


ΓòÉΓòÉΓòÉ 24. Index ΓòÉΓòÉΓòÉ

Sorry, no cp index


ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ

Any more